gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "flags.h"
  36 #include "cp-tree.h"
  37 #include "decl.h"
  38 #include "lex.h"
  39 #include <signal.h>
  40 #include "defaults.h"
  41 #include "output.h"
  42 #include "except.h"
  43 #include "toplev.h"
  44 #include "../hash.h"
  45 #include "defaults.h"
  46 #include "ggc.h"
  47
  48 extern int current_class_depth;
  49
  50 extern tree static_ctors, static_dtors;
  51
  52 extern tree global_namespace;
  53
  54 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  55
  56 /* Use garbage collection.  */
  57
  58 int ggc_p = 1;
  59
  60 #ifndef WCHAR_UNSIGNED
  61 #define WCHAR_UNSIGNED 0
  62 #endif
  63
  64 #ifndef CHAR_TYPE_SIZE
  65 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  66 #endif
  67
  68 #ifndef BOOL_TYPE_SIZE
  69 #ifdef SLOW_BYTE_ACCESS
  70 /* In the new ABI, `bool' has size and alignment `1', on all
  71    platforms.  */
  72 #define BOOL_TYPE_SIZE \
  73   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  74 #else
  75 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  76 #endif
  77 #endif
  78
  79 /* We let tm.h override the types used here, to handle trivial differences
  80    such as the choice of unsigned int or long unsigned int for size_t.
  81    When machines start needing nontrivial differences in the size type,
  82    it would be best to do something here to figure out automatically
  83    from other information what type to use.  */
  84
  85 #ifndef SIZE_TYPE
  86 #define SIZE_TYPE "long unsigned int"
  87 #endif
  88
  89 #ifndef PTRDIFF_TYPE
  90 #define PTRDIFF_TYPE "long int"
  91 #endif
  92
  93 #ifndef WCHAR_TYPE
  94 #define WCHAR_TYPE "int"
  95 #endif
  96
  97 static tree grokparms                           PARAMS ((tree, int));
  98 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  99
 100 static void push_binding_level PARAMS ((struct binding_level *, int,
 101                                       int));
 102 static void pop_binding_level PARAMS ((void));
 103 static void suspend_binding_level PARAMS ((void));
 104 static void resume_binding_level PARAMS ((struct binding_level *));
 105 static struct binding_level *make_binding_level PARAMS ((void));
 106 static void declare_namespace_level PARAMS ((void));
 107 static void signal_catch PARAMS ((int)) ATTRIBUTE_NORETURN;
 108 static void storedecls PARAMS ((tree));
 109 static void require_complete_types_for_parms PARAMS ((tree));
 110 static int ambi_op_p PARAMS ((tree));
 111 static int unary_op_p PARAMS ((tree));
 112 static tree store_bindings PARAMS ((tree, tree));
 113 static tree lookup_tag_reverse PARAMS ((tree, tree));
 114 static tree obscure_complex_init PARAMS ((tree, tree));
 115 static tree lookup_name_real PARAMS ((tree, int, int, int));
 116 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 117 static void grok_reference_init PARAMS ((tree, tree, tree));
 118 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 119                               enum overload_flags, tree,
 120                               tree, int, int, int, int, int, int, tree));
 121 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 122 static tree lookup_tag PARAMS ((enum tree_code, tree,
 123                               struct binding_level *, int));
 124 static void set_identifier_type_value_with_scope
 125         PARAMS ((tree, tree, struct binding_level *));
 126 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 127 static void record_unknown_type PARAMS ((tree, const char *));
 128 static tree build_library_fn_1                  PARAMS ((tree, tree));
 129 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 130 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 131                                   int));
 132 static void lang_print_error_function PARAMS ((const char *));
 133 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 134 static void check_for_uninitialized_const_var PARAMS ((tree));
 135 static unsigned long typename_hash PARAMS ((hash_table_key));
 136 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 137 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 138 static int add_binding PARAMS ((tree, tree));
 139 static void pop_binding PARAMS ((tree, tree));
 140 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 141 static tree find_binding PARAMS ((tree, tree));
 142 static tree select_decl PARAMS ((tree, int));
 143 static int lookup_flags PARAMS ((int, int));
 144 static tree qualify_lookup PARAMS ((tree, int));
 145 static tree record_builtin_java_type PARAMS ((const char *, int));
 146 static const char *tag_name PARAMS ((enum tag_types code));
 147 static void find_class_binding_level PARAMS ((void));
 148 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 149 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 150 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 151 static int walk_globals_r PARAMS ((tree, void *));
 152 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 153 static tree make_label_decl PARAMS ((tree, int));
 154 static void pop_label PARAMS ((tree));
 155 static void pop_labels PARAMS ((tree));
 156 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 157 static void layout_var_decl PARAMS ((tree));
 158 static void maybe_commonize_var PARAMS ((tree));
 159 static tree check_initializer PARAMS ((tree, tree));
 160 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 161 static void push_cp_function_context PARAMS ((struct function *));
 162 static void pop_cp_function_context PARAMS ((struct function *));
 163 static void mark_binding_level PARAMS ((void *));
 164 static void mark_cp_function_context PARAMS ((struct function *));
 165 static void mark_saved_scope PARAMS ((void *));
 166 static void mark_lang_function PARAMS ((struct language_function *));
 167 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 168 static void save_function_data PARAMS ((tree));
 169 static void check_function_type PARAMS ((tree));
 170 static void destroy_local_var PARAMS ((tree));
 171 static void finish_constructor_body PARAMS ((void));
 172 static void finish_destructor_body PARAMS ((void));
 173 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 174 static tree get_atexit_node PARAMS ((void));
 175 static tree get_dso_handle_node PARAMS ((void));
 176 static tree start_cleanup_fn PARAMS ((void));
 177 static void end_cleanup_fn PARAMS ((void));
 178 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 179 static void initialize_predefined_identifiers PARAMS ((void));
 180 static tree check_special_function_return_type
 181   PARAMS ((special_function_kind, tree, tree, tree));
 182
 183 #if defined (DEBUG_CP_BINDING_LEVELS)
 184 static void indent PARAMS ((void));
 185 #endif
 186
 187 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 188 tree error_mark_list;
 189
 190 /* The following symbols are subsumed in the cp_global_trees array, and
 191    listed here individually for documentation purposes.
 192
 193    C++ extensions
 194         tree wchar_decl_node;
 195         tree void_zero_node;
 196
 197         tree vtable_entry_type;
 198         tree delta_type_node;
 199 #if 0
 200    Old rtti stuff.
 201         tree __baselist_desc_type_node;
 202         tree __i_desc_type_node, __m_desc_type_node;
 203         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 204 #endif
 205         tree __t_desc_type_node;
 206 #if 0
 207         tree __tp_desc_type_node;
 208 #endif
 209         tree ti_desc_type_node;
 210         tree bltn_desc_type_node, ptr_desc_type_node;
 211         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 212         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 213         tree ptm_desc_type_node;
 214         tree base_desc_type_node;
 215 #if 0
 216    Not needed yet?  May be needed one day?
 217         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 218         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 219         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 220 #endif
 221
 222         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 223         tree unknown_type_node;
 224
 225    Array type `vtable_entry_type[]'
 226
 227         tree vtbl_type_node;
 228         tree vtbl_ptr_type_node;
 229
 230    Namespaces,
 231
 232         tree std_node;
 233         tree abi_node;
 234
 235    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 236    one that the user will declare, but sufficient to be called
 237    by routines that want to abort the program.
 238
 239         tree abort_fndecl;
 240
 241    The FUNCTION_DECL for the default `::operator delete'.
 242
 243         tree global_delete_fndecl;
 244
 245    Used by RTTI
 246         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 247         tree tinfo_var_id;
 248
 249 */
 250
 251 tree cp_global_trees[CPTI_MAX];
 252
 253 /* Indicates that there is a type value in some namespace, although
 254    that is not necessarily in scope at the moment.  */
 255
 256 static tree global_type_node;
 257
 258 /* Namespace std.  */
 259 int in_std;
 260
 261 /* Expect only namespace names now. */
 262 static int only_namespace_names;
 263
 264 /* If original DECL_RESULT of current function was a register,
 265    but due to being an addressable named return value, would up
 266    on the stack, this variable holds the named return value's
 267    original location.  */
 268
 269 #define original_result_rtx cp_function_chain->x_result_rtx
 270
 271 struct named_label_list
 272 {
 273   struct binding_level *binding_level;
 274   tree names_in_scope;
 275   tree label_decl;
 276   const char *filename_o_goto;
 277   int lineno_o_goto;
 278   struct named_label_list *next;
 279 };
 280
 281 /* Used only for jumps to as-yet undefined labels, since jumps to
 282    defined labels can have their validity checked by stmt.c.  */
 283
 284 #define named_label_uses cp_function_chain->x_named_label_uses
 285
 286 /* A list of objects which have constructors or destructors
 287    which reside in the global scope.  The decl is stored in
 288    the TREE_VALUE slot and the initializer is stored
 289    in the TREE_PURPOSE slot.  */
 290 tree static_aggregates;
 291
 292 /* -- end of C++ */
 293
 294 /* A node for the integer constants 2, and 3.  */
 295
 296 tree integer_two_node, integer_three_node;
 297
 298 /* Parsing a function declarator leaves here a chain of structure
 299    and enum types declared in the parmlist.  */
 300
 301 static tree last_function_parm_tags;
 302
 303 /* Similar, for last_function_parm_tags.  */
 304 tree last_function_parms;
 305 static tree current_function_parm_tags;
 306
 307 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 308    that have names.  Here so we can clear out their names' definitions
 309    at the end of the function.  The TREE_VALUE is a LABEL_DECL; the
 310    TREE_PURPOSE is the previous binding of the label.  */
 311
 312 #define named_labels cp_function_chain->x_named_labels
 313
 314 /* Set to 0 at beginning of a function definition, and whenever
 315    a label (case or named) is defined.  Set to value of expression
 316    returned from function when that value can be transformed into
 317    a named return value.  */
 318
 319 tree current_function_return_value;
 320
 321 /* Nonzero means use the ISO C99 dialect of C.  */
 322
 323 int flag_isoc99;
 324
 325 /* Nonzero means give `double' the same size as `float'.  */
 326
 327 extern int flag_short_double;
 328
 329 /* Nonzero means don't recognize any builtin functions.  */
 330
 331 extern int flag_no_builtin;
 332
 333 /* Nonzero means don't recognize the non-ANSI builtin functions.
 334    -ansi sets this.  */
 335
 336 extern int flag_no_nonansi_builtin;
 337
 338 /* Nonzero if we want to conserve space in the .o files.  We do this
 339    by putting uninitialized data and runtime initialized data into
 340    .common instead of .data at the expense of not flagging multiple
 341    definitions.  */
 342 extern int flag_conserve_space;
 343 \f
 344 /* C and C++ flags are in decl2.c.  */
 345
 346 /* Flag used when debugging spew.c */
 347
 348 extern int spew_debug;
 349
 350 /* A expression of value 0 with the same precision as a sizetype
 351    node, but signed.  */
 352 tree signed_size_zero_node;
 353
 354 /* The name of the anonymous namespace, throughout this translation
 355    unit.  */
 356 tree anonymous_namespace_name;
 357
 358 \f
 359 /* For each binding contour we allocate a binding_level structure
 360    which records the names defined in that contour.
 361    Contours include:
 362     0) the global one
 363     1) one for each function definition,
 364        where internal declarations of the parameters appear.
 365     2) one for each compound statement,
 366        to record its declarations.
 367
 368    The current meaning of a name can be found by searching the levels
 369    from the current one out to the global one.
 370
 371    Off to the side, may be the class_binding_level.  This exists only
 372    to catch class-local declarations.  It is otherwise nonexistent.
 373
 374    Also there may be binding levels that catch cleanups that must be
 375    run when exceptions occur.  Thus, to see whether a name is bound in
 376    the current scope, it is not enough to look in the
 377    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 378    instead.  */
 379
 380 /* Note that the information in the `names' component of the global contour
 381    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 382
 383 struct binding_level
 384   {
 385     /* A chain of _DECL nodes for all variables, constants, functions,
 386        and typedef types.  These are in the reverse of the order
 387        supplied.  There may be OVERLOADs on this list, too, but they
 388        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 389     tree names;
 390
 391     /* A list of structure, union and enum definitions, for looking up
 392        tag names.
 393        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 394        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 395        or ENUMERAL_TYPE node.
 396
 397        C++: the TREE_VALUE nodes can be simple types for
 398        component_bindings.  */
 399     tree tags;
 400
 401     /* A list of USING_DECL nodes. */
 402     tree usings;
 403
 404     /* A list of used namespaces. PURPOSE is the namespace,
 405        VALUE the common ancestor with this binding_level's namespace. */
 406     tree using_directives;
 407
 408     /* If this binding level is the binding level for a class, then
 409        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 410        is the name of an entity bound in the class; the TREE_VALUE is
 411        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 412        when leaving class scope, we can restore the
 413        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 414        the DECL bound by this name in the class.  */
 415     tree class_shadowed;
 416
 417     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 418        is used for all binding levels.  */
 419     tree type_shadowed;
 420
 421     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 422        label in this scope.  The TREE_PURPOSE is the previous value of
 423        the IDENTIFIER_LABEL VALUE.  */
 424     tree shadowed_labels;
 425
 426     /* For each level (except not the global one),
 427        a chain of BLOCK nodes for all the levels
 428        that were entered and exited one level down.  */
 429     tree blocks;
 430
 431     /* The BLOCK node for this level, if one has been preallocated.
 432        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 433     tree this_block;
 434
 435     /* The _TYPE node for this level, if parm_flag == 2.  */
 436     tree this_class;
 437
 438     /* The binding level which this one is contained in (inherits from).  */
 439     struct binding_level *level_chain;
 440
 441     /* List of decls in `names' that have incomplete
 442        structure or union types.  */
 443     tree incomplete;
 444
 445     /* List of VAR_DECLS saved from a previous for statement.
 446        These would be dead in ISO-conforming code, but might
 447        be referenced in ARM-era code.  These are stored in a
 448        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 449     tree dead_vars_from_for;
 450
 451     /* 1 for the level that holds the parameters of a function.
 452        2 for the level that holds a class declaration.  */
 453     unsigned parm_flag : 2;
 454
 455     /* 1 means make a BLOCK for this level regardless of all else.
 456        2 for temporary binding contours created by the compiler.  */
 457     unsigned keep : 2;
 458
 459     /* Nonzero if this level "doesn't exist" for tags.  */
 460     unsigned tag_transparent : 1;
 461
 462     /* Nonzero if this level can safely have additional
 463        cleanup-needing variables added to it.  */
 464     unsigned more_cleanups_ok : 1;
 465     unsigned have_cleanups : 1;
 466
 467     /* Nonzero if this scope is for storing the decls for template
 468        parameters and generic decls; these decls will be discarded and
 469        replaced with a TEMPLATE_DECL.  */
 470     unsigned template_parms_p : 1;
 471
 472     /* Nonzero if this scope corresponds to the `<>' in a
 473        `template <>' clause.  Whenever this flag is set,
 474        TEMPLATE_PARMS_P will be set as well.  */
 475     unsigned template_spec_p : 1;
 476
 477     /* This is set for a namespace binding level.  */
 478     unsigned namespace_p : 1;
 479
 480     /* True if this level is that of a for-statement where we need to
 481        worry about ambiguous (ARM or ISO) scope rules.  */
 482     unsigned is_for_scope : 1;
 483
 484     /* True if this level corresponds to an EH region, as for a try block.  */
 485     unsigned eh_region : 1;
 486
 487     /* Four bits left for this word.  */
 488
 489 #if defined(DEBUG_CP_BINDING_LEVELS)
 490     /* Binding depth at which this level began.  */
 491     unsigned binding_depth;
 492 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 493   };
 494
 495 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 496
 497 /* The binding level currently in effect.  */
 498
 499 #define current_binding_level                   \
 500   (cfun                                         \
 501    ? cp_function_chain->bindings                \
 502    : scope_chain->bindings)
 503
 504 /* The binding level of the current class, if any.  */
 505
 506 #define class_binding_level scope_chain->class_bindings
 507
 508 /* A chain of binding_level structures awaiting reuse.  */
 509
 510 static struct binding_level *free_binding_level;
 511
 512 /* The outermost binding level, for names of file scope.
 513    This is created when the compiler is started and exists
 514    through the entire run.  */
 515
 516 static struct binding_level *global_binding_level;
 517
 518 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 519
 520 static int keep_next_level_flag;
 521
 522 #if defined(DEBUG_CP_BINDING_LEVELS)
 523 static int binding_depth = 0;
 524 static int is_class_level = 0;
 525
 526 static void
 527 indent ()
 528 {
 529   register unsigned i;
 530
 531   for (i = 0; i < binding_depth*2; i++)
 532     putc (' ', stderr);
 533 }
 534 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 535
 536 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 537
 538 static void
 539 push_binding_level (newlevel, tag_transparent, keep)
 540      struct binding_level *newlevel;
 541      int tag_transparent, keep;
 542 {
 543   /* Add this level to the front of the chain (stack) of levels that
 544      are active.  */
 545   bzero ((char*) newlevel, sizeof (struct binding_level));
 546   newlevel->level_chain = current_binding_level;
 547   current_binding_level = newlevel;
 548   newlevel->tag_transparent = tag_transparent;
 549   newlevel->more_cleanups_ok = 1;
 550
 551   /* We are called before expand_start_bindings, but after
 552      expand_eh_region_start for a try block; so we check this now,
 553      before the EH block is covered up.  */
 554   newlevel->eh_region = is_eh_region ();
 555
 556   newlevel->keep = keep;
 557 #if defined(DEBUG_CP_BINDING_LEVELS)
 558   newlevel->binding_depth = binding_depth;
 559   indent ();
 560   fprintf (stderr, "push %s level 0x%08x line %d\n",
 561            (is_class_level) ? "class" : "block", newlevel, lineno);
 562   is_class_level = 0;
 563   binding_depth++;
 564 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 565 }
 566
 567 /* Find the innermost enclosing class scope, and reset
 568    CLASS_BINDING_LEVEL appropriately.  */
 569
 570 static void
 571 find_class_binding_level ()
 572 {
 573   struct binding_level *level = current_binding_level;
 574
 575   while (level && level->parm_flag != 2)
 576     level = level->level_chain;
 577   if (level && level->parm_flag == 2)
 578     class_binding_level = level;
 579   else
 580     class_binding_level = 0;
 581 }
 582
 583 static void
 584 pop_binding_level ()
 585 {
 586   if (global_binding_level)
 587     {
 588       /* Cannot pop a level, if there are none left to pop.  */
 589       if (current_binding_level == global_binding_level)
 590         my_friendly_abort (123);
 591     }
 592   /* Pop the current level, and free the structure for reuse.  */
 593 #if defined(DEBUG_CP_BINDING_LEVELS)
 594   binding_depth--;
 595   indent ();
 596   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 597           (is_class_level) ? "class" : "block",
 598           current_binding_level, lineno);
 599   if (is_class_level != (current_binding_level == class_binding_level))
 600     {
 601       indent ();
 602       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 603     }
 604   is_class_level = 0;
 605 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 606   {
 607     register struct binding_level *level = current_binding_level;
 608     current_binding_level = current_binding_level->level_chain;
 609     level->level_chain = free_binding_level;
 610 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 611     if (level->binding_depth != binding_depth)
 612       abort ();
 613 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 614     free_binding_level = level;
 615     find_class_binding_level ();
 616   }
 617 }
 618
 619 static void
 620 suspend_binding_level ()
 621 {
 622   if (class_binding_level)
 623     current_binding_level = class_binding_level;
 624
 625   if (global_binding_level)
 626     {
 627       /* Cannot suspend a level, if there are none left to suspend.  */
 628       if (current_binding_level == global_binding_level)
 629         my_friendly_abort (123);
 630     }
 631   /* Suspend the current level.  */
 632 #if defined(DEBUG_CP_BINDING_LEVELS)
 633   binding_depth--;
 634   indent ();
 635   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 636           (is_class_level) ? "class" : "block",
 637           current_binding_level, lineno);
 638   if (is_class_level != (current_binding_level == class_binding_level))
 639     {
 640       indent ();
 641       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 642     }
 643   is_class_level = 0;
 644 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 645   current_binding_level = current_binding_level->level_chain;
 646   find_class_binding_level ();
 647 }
 648
 649 static void
 650 resume_binding_level (b)
 651      struct binding_level *b;
 652 {
 653   /* Resuming binding levels is meant only for namespaces,
 654      and those cannot nest into classes. */
 655   my_friendly_assert(!class_binding_level, 386);
 656   /* Also, resuming a non-directly nested namespace is a no-no.  */
 657   my_friendly_assert(b->level_chain == current_binding_level, 386);
 658   current_binding_level = b;
 659 #if defined(DEBUG_CP_BINDING_LEVELS)
 660   b->binding_depth = binding_depth;
 661   indent ();
 662   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 663            (is_class_level) ? "class" : "block", b, lineno);
 664   is_class_level = 0;
 665   binding_depth++;
 666 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 667 }
 668 \f
 669 /* Create a new `struct binding_level'.  */
 670
 671 static
 672 struct binding_level *
 673 make_binding_level ()
 674 {
 675   /* NOSTRICT */
 676   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 677 }
 678
 679 /* Nonzero if we are currently in the global binding level.  */
 680
 681 int
 682 global_bindings_p ()
 683 {
 684   return current_binding_level == global_binding_level;
 685 }
 686
 687 /* Return the innermost binding level that is not for a class scope.  */
 688
 689 static struct binding_level *
 690 innermost_nonclass_level ()
 691 {
 692   struct binding_level *b;
 693
 694   b = current_binding_level;
 695   while (b->parm_flag == 2)
 696     b = b->level_chain;
 697
 698   return b;
 699 }
 700
 701 /* Nonzero if we are currently in a toplevel binding level.  This
 702    means either the global binding level or a namespace in a toplevel
 703    binding level.  Since there are no non-toplevel namespace levels,
 704    this really means any namespace or template parameter level.  We
 705    also include a class whose context is toplevel.  */
 706
 707 int
 708 toplevel_bindings_p ()
 709 {
 710   struct binding_level *b = innermost_nonclass_level ();
 711
 712   return b->namespace_p || b->template_parms_p;
 713 }
 714
 715 /* Nonzero if this is a namespace scope, or if we are defining a class
 716    which is itself at namespace scope, or whose enclosing class is
 717    such a class, etc.  */
 718
 719 int
 720 namespace_bindings_p ()
 721 {
 722   struct binding_level *b = innermost_nonclass_level ();
 723
 724   return b->namespace_p;
 725 }
 726
 727 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 728    unconditionally.  Otherwise, use the normal logic to decide whether
 729    or not to create a BLOCK.  */
 730
 731 void
 732 keep_next_level (keep)
 733      int keep;
 734 {
 735   keep_next_level_flag = keep;
 736 }
 737
 738 /* Nonzero if the current level needs to have a BLOCK made.  */
 739
 740 int
 741 kept_level_p ()
 742 {
 743   return (current_binding_level->blocks != NULL_TREE
 744           || current_binding_level->keep
 745           || current_binding_level->names != NULL_TREE
 746           || (current_binding_level->tags != NULL_TREE
 747               && !current_binding_level->tag_transparent));
 748 }
 749
 750 static void
 751 declare_namespace_level ()
 752 {
 753   current_binding_level->namespace_p = 1;
 754 }
 755
 756 /* Returns non-zero if this scope was created to store template
 757    parameters.  */
 758
 759 int
 760 template_parm_scope_p ()
 761 {
 762   return current_binding_level->template_parms_p;
 763 }
 764
 765 /* Returns the kind of template specialization we are currently
 766    processing, given that it's declaration contained N_CLASS_SCOPES
 767    explicit scope qualifications.  */
 768
 769 tmpl_spec_kind
 770 current_tmpl_spec_kind (n_class_scopes)
 771      int n_class_scopes;
 772 {
 773   int n_template_parm_scopes = 0;
 774   int seen_specialization_p = 0;
 775   int innermost_specialization_p = 0;
 776   struct binding_level *b;
 777
 778   /* Scan through the template parameter scopes.  */
 779   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 780     {
 781       /* If we see a specialization scope inside a parameter scope,
 782          then something is wrong.  That corresponds to a declaration
 783          like:
 784
 785             template <class T> template <> ...
 786
 787          which is always illegal since [temp.expl.spec] forbids the
 788          specialization of a class member template if the enclosing
 789          class templates are not explicitly specialized as well.  */
 790       if (b->template_spec_p)
 791         {
 792           if (n_template_parm_scopes == 0)
 793             innermost_specialization_p = 1;
 794           else
 795             seen_specialization_p = 1;
 796         }
 797       else if (seen_specialization_p == 1)
 798         return tsk_invalid_member_spec;
 799
 800       ++n_template_parm_scopes;
 801     }
 802
 803   /* Handle explicit instantiations.  */
 804   if (processing_explicit_instantiation)
 805     {
 806       if (n_template_parm_scopes != 0)
 807         /* We've seen a template parameter list during an explicit
 808            instantiation.  For example:
 809
 810              template <class T> template void f(int);
 811
 812            This is erroneous.  */
 813         return tsk_invalid_expl_inst;
 814       else
 815         return tsk_expl_inst;
 816     }
 817
 818   if (n_template_parm_scopes < n_class_scopes)
 819     /* We've not seen enough template headers to match all the
 820        specialized classes present.  For example:
 821
 822          template <class T> void R<T>::S<T>::f(int);
 823
 824        This is illegal; there needs to be one set of template
 825        parameters for each class.  */
 826     return tsk_insufficient_parms;
 827   else if (n_template_parm_scopes == n_class_scopes)
 828     /* We're processing a non-template declaration (even though it may
 829        be a member of a template class.)  For example:
 830
 831          template <class T> void S<T>::f(int);
 832
 833        The `class T' maches the `S<T>', leaving no template headers
 834        corresponding to the `f'.  */
 835     return tsk_none;
 836   else if (n_template_parm_scopes > n_class_scopes + 1)
 837     /* We've got too many template headers.  For example:
 838
 839          template <> template <class T> void f (T);
 840
 841        There need to be more enclosing classes.  */
 842     return tsk_excessive_parms;
 843   else
 844     /* This must be a template.  It's of the form:
 845
 846          template <class T> template <class U> void S<T>::f(U);
 847
 848        This is a specialization if the innermost level was a
 849        specialization; otherwise it's just a definition of the
 850        template.  */
 851     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 852 }
 853
 854 void
 855 set_class_shadows (shadows)
 856      tree shadows;
 857 {
 858   class_binding_level->class_shadowed = shadows;
 859 }
 860
 861 /* Enter a new binding level.
 862    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 863    not for that of tags.  */
 864
 865 void
 866 pushlevel (tag_transparent)
 867      int tag_transparent;
 868 {
 869   struct binding_level *newlevel;
 870
 871   if (cfun && !doing_semantic_analysis_p ())
 872     return;
 873
 874   /* Reuse or create a struct for this binding level.  */
 875 #if defined(DEBUG_CP_BINDING_LEVELS)
 876   if (0)
 877 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 878   if (free_binding_level)
 879 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 880     {
 881       newlevel = free_binding_level;
 882       free_binding_level = free_binding_level->level_chain;
 883     }
 884   else
 885     newlevel = make_binding_level ();
 886
 887   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 888   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 889   keep_next_level_flag = 0;
 890 }
 891
 892 /* Enter a new scope.  The KIND indicates what kind of scope is being
 893    created.  */
 894
 895 void
 896 begin_scope (sk)
 897      scope_kind sk;
 898 {
 899   pushlevel (0);
 900
 901   switch (sk)
 902     {
 903     case sk_template_spec:
 904       current_binding_level->template_spec_p = 1;
 905       /* Fall through.  */
 906
 907     case sk_template_parms:
 908       current_binding_level->template_parms_p = 1;
 909       break;
 910
 911     default:
 912       my_friendly_abort (20000309);
 913     }
 914 }
 915
 916 /* Exit the current scope.  */
 917
 918 void
 919 finish_scope ()
 920 {
 921   poplevel (0, 0, 0);
 922 }
 923
 924 void
 925 note_level_for_for ()
 926 {
 927   current_binding_level->is_for_scope = 1;
 928 }
 929
 930 /* For a binding between a name and an entity at a block scope,
 931    this is the `struct binding_level' for the block.  */
 932 #define BINDING_LEVEL(NODE) \
 933    (((struct tree_binding*)NODE)->scope.level)
 934
 935 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 936    level at which this declaration is being bound.  */
 937
 938 static void
 939 push_binding (id, decl, level)
 940      tree id;
 941      tree decl;
 942      struct binding_level* level;
 943 {
 944   tree binding;
 945
 946   binding = make_node (CPLUS_BINDING);
 947
 948   /* Now, fill in the binding information.  */
 949   BINDING_VALUE (binding) = decl;
 950   BINDING_TYPE (binding) = NULL_TREE;
 951   BINDING_LEVEL (binding) = level;
 952   INHERITED_VALUE_BINDING_P (binding) = 0;
 953   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 954   BINDING_HAS_LEVEL_P (binding) = 1;
 955
 956   /* And put it on the front of the list of bindings for ID.  */
 957   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 958   IDENTIFIER_BINDING (id) = binding;
 959 }
 960
 961 /* ID is already bound in the current scope.  But, DECL is an
 962    additional binding for ID in the same scope.  This is the `struct
 963    stat' hack whereby a non-typedef class-name or enum-name can be
 964    bound at the same level as some other kind of entity.  It's the
 965    responsibility of the caller to check that inserting this name is
 966    legal here.  Returns nonzero if the new binding was successful.  */
 967 static int
 968 add_binding (id, decl)
 969      tree id;
 970      tree decl;
 971 {
 972   tree binding = IDENTIFIER_BINDING (id);
 973   int ok = 1;
 974
 975   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 976     /* The new name is the type name.  */
 977     BINDING_TYPE (binding) = decl;
 978   else if (!BINDING_VALUE (binding))
 979     /* This situation arises when push_class_level_binding moves an
 980        inherited type-binding out of the way to make room for a new
 981        value binding.  */
 982     BINDING_VALUE (binding) = decl;
 983   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 984            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 985     {
 986       /* The old binding was a type name.  It was placed in
 987          BINDING_VALUE because it was thought, at the point it was
 988          declared, to be the only entity with such a name.  Move the
 989          type name into the type slot; it is now hidden by the new
 990          binding.  */
 991       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 992       BINDING_VALUE (binding) = decl;
 993       INHERITED_VALUE_BINDING_P (binding) = 0;
 994     }
 995   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 996            && TREE_CODE (decl) == TYPE_DECL
 997            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 998            && same_type_p (TREE_TYPE (decl),
 999                            TREE_TYPE (BINDING_VALUE (binding))))
1000     /* We have two typedef-names, both naming the same type to have
1001        the same name.  This is OK because of:
1002
1003          [dcl.typedef]
1004
1005          In a given scope, a typedef specifier can be used to redefine
1006          the name of any type declared in that scope to refer to the
1007          type to which it already refers.  */
1008     ok = 0;
1009   else
1010     {
1011       cp_error ("declaration of `%#D'", decl);
1012       cp_error_at ("conflicts with previous declaration `%#D'",
1013                    BINDING_VALUE (binding));
1014       ok = 0;
1015     }
1016
1017   return ok;
1018 }
1019
1020 /* Add DECL to the list of things declared in B.  */
1021
1022 static void
1023 add_decl_to_level (decl, b)
1024      tree decl;
1025      struct binding_level *b;
1026 {
1027   /* We build up the list in reverse order, and reverse it later if
1028      necessary.  */
1029   TREE_CHAIN (decl) = b->names;
1030   b->names = decl;
1031 }
1032
1033 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1034    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1035    doesn't really belong to this binding level, that it got here
1036    through a using-declaration.  */
1037
1038 void
1039 push_local_binding (id, decl, flags)
1040      tree id;
1041      tree decl;
1042      int flags;
1043 {
1044   struct binding_level *b;
1045
1046   /* Skip over any local classes.  This makes sense if we call
1047      push_local_binding with a friend decl of a local class.  */
1048   b = current_binding_level;
1049   while (b->parm_flag == 2)
1050     b = b->level_chain;
1051
1052   if (lookup_name_current_level (id))
1053     {
1054       /* Supplement the existing binding.  */
1055       if (!add_binding (id, decl))
1056         /* It didn't work.  Something else must be bound at this
1057            level.  Do not add DECL to the list of things to pop
1058            later.  */
1059         return;
1060     }
1061   else
1062     /* Create a new binding.  */
1063     push_binding (id, decl, b);
1064
1065   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1066     /* We must put the OVERLOAD into a TREE_LIST since the
1067        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1068        decls that got here through a using-declaration.  */
1069     decl = build_tree_list (NULL_TREE, decl);
1070
1071   /* And put DECL on the list of things declared by the current
1072      binding level.  */
1073   add_decl_to_level (decl, b);
1074 }
1075
1076 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1077    binding was successful.  */
1078
1079 int
1080 push_class_binding (id, decl)
1081      tree id;
1082      tree decl;
1083 {
1084   int result = 1;
1085   tree binding = IDENTIFIER_BINDING (id);
1086   tree context;
1087
1088   /* Note that we declared this value so that we can issue an error if
1089      this an illegal redeclaration of a name already used for some
1090      other purpose.  */
1091   note_name_declared_in_class (id, decl);
1092
1093   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1094     /* Supplement the existing binding.  */
1095     result = add_binding (id, decl);
1096   else
1097     /* Create a new binding.  */
1098     push_binding (id, decl, class_binding_level);
1099
1100   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1101      class-level declaration.  Note that we do not use DECL here
1102      because of the possibility of the `struct stat' hack; if DECL is
1103      a class-name or enum-name we might prefer a field-name, or some
1104      such.  */
1105   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1106
1107   /* If this is a binding from a base class, mark it as such.  */
1108   binding = IDENTIFIER_BINDING (id);
1109   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1110     {
1111       /* Any implicit typename must be from a base-class.  The
1112          context for an implicit typename declaration is always
1113          the derived class in which the lookup was done, so the checks
1114          based on the context of DECL below will not trigger.  */
1115       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1116         INHERITED_VALUE_BINDING_P (binding) = 1;
1117       else
1118         {
1119           if (TREE_CODE (decl) == OVERLOAD)
1120             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1121           else
1122             {
1123               my_friendly_assert (DECL_P (decl), 0);
1124               context = CP_DECL_CONTEXT (decl);
1125             }
1126
1127           if (is_properly_derived_from (current_class_type, context))
1128             INHERITED_VALUE_BINDING_P (binding) = 1;
1129           else
1130             INHERITED_VALUE_BINDING_P (binding) = 0;
1131         }
1132     }
1133   else if (BINDING_VALUE (binding) == decl)
1134     /* We only encounter a TREE_LIST when push_class_decls detects an
1135        ambiguity.  Such an ambiguity can be overridden by a definition
1136        in this class.  */
1137     INHERITED_VALUE_BINDING_P (binding) = 1;
1138
1139   return result;
1140 }
1141
1142 /* Remove the binding for DECL which should be the innermost binding
1143    for ID.  */
1144
1145 static void
1146 pop_binding (id, decl)
1147      tree id;
1148      tree decl;
1149 {
1150   tree binding;
1151
1152   if (id == NULL_TREE)
1153     /* It's easiest to write the loops that call this function without
1154        checking whether or not the entities involved have names.  We
1155        get here for such an entity.  */
1156     return;
1157
1158   /* Get the innermost binding for ID.  */
1159   binding = IDENTIFIER_BINDING (id);
1160
1161   /* The name should be bound.  */
1162   my_friendly_assert (binding != NULL_TREE, 0);
1163
1164   /* The DECL will be either the ordinary binding or the type
1165      binding for this identifier.  Remove that binding.  */
1166   if (BINDING_VALUE (binding) == decl)
1167     BINDING_VALUE (binding) = NULL_TREE;
1168   else if (BINDING_TYPE (binding) == decl)
1169     BINDING_TYPE (binding) = NULL_TREE;
1170   else
1171     my_friendly_abort (0);
1172
1173   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1174     /* We're completely done with the innermost binding for this
1175        identifier.  Unhook it from the list of bindings.  */
1176     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1177 }
1178
1179 /* When a label goes out of scope, check to see if that label was used
1180    in a valid manner, and issue any appropriate warnings or errors.  */
1181
1182 static void
1183 pop_label (link)
1184      tree link;
1185 {
1186   tree label = TREE_VALUE (link);
1187
1188   if (!processing_template_decl && doing_semantic_analysis_p ())
1189     {
1190       if (DECL_INITIAL (label) == NULL_TREE)
1191         {
1192           cp_error_at ("label `%D' used but not defined", label);
1193           /* Avoid crashing later.  */
1194           define_label (input_filename, 1, DECL_NAME (label));
1195         }
1196       else if (warn_unused_label && !TREE_USED (label))
1197         cp_warning_at ("label `%D' defined but not used", label);
1198     }
1199
1200   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), TREE_PURPOSE (link));
1201 }
1202
1203 /* At the end of a function, all labels declared within the fucntion
1204    go out of scope.  BLOCK is the top-level block for the
1205    function.  */
1206
1207 static void
1208 pop_labels (block)
1209      tree block;
1210 {
1211   tree link;
1212
1213   /* Clear out the definitions of all label names, since their scopes
1214      end here.  */
1215   for (link = named_labels; link; link = TREE_CHAIN (link))
1216     {
1217       pop_label (link);
1218       /* Put the labels into the "variables" of the top-level block,
1219          so debugger can see them.  */
1220       TREE_CHAIN (TREE_VALUE (link)) = BLOCK_VARS (block);
1221       BLOCK_VARS (block) = TREE_VALUE (link);
1222     }
1223
1224   named_labels = NULL_TREE;
1225 }
1226
1227 /* Exit a binding level.
1228    Pop the level off, and restore the state of the identifier-decl mappings
1229    that were in effect when this level was entered.
1230
1231    If KEEP == 1, this level had explicit declarations, so
1232    and create a "block" (a BLOCK node) for the level
1233    to record its declarations and subblocks for symbol table output.
1234
1235    If FUNCTIONBODY is nonzero, this level is the body of a function,
1236    so create a block as if KEEP were set and also clear out all
1237    label names.
1238
1239    If REVERSE is nonzero, reverse the order of decls before putting
1240    them into the BLOCK.  */
1241
1242 tree
1243 poplevel (keep, reverse, functionbody)
1244      int keep;
1245      int reverse;
1246      int functionbody;
1247 {
1248   register tree link;
1249   /* The chain of decls was accumulated in reverse order.
1250      Put it into forward order, just for cleanliness.  */
1251   tree decls;
1252   int tmp = functionbody;
1253   int real_functionbody;
1254   tree tags;
1255   tree subblocks;
1256   tree block = NULL_TREE;
1257   tree decl;
1258   int block_previously_created;
1259   int leaving_for_scope;
1260
1261   if (cfun && !doing_semantic_analysis_p ())
1262     return NULL_TREE;
1263
1264   my_friendly_assert (current_binding_level->parm_flag != 2,
1265                       19990916);
1266
1267   real_functionbody = (current_binding_level->keep == 2
1268                        ? ((functionbody = 0), tmp) : functionbody);
1269   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1270   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1271
1272   my_friendly_assert (!current_binding_level->class_shadowed,
1273                       19990414);
1274
1275   /* We used to use KEEP == 2 to indicate that the new block should go
1276      at the beginning of the list of blocks at this binding level,
1277      rather than the end.  This hack is no longer used.  */
1278   my_friendly_assert (keep == 0 || keep == 1, 0);
1279
1280   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1281                       (HOST_WIDE_INT) current_binding_level->level_chain,
1282                       current_binding_level->parm_flag,
1283                       current_binding_level->keep);
1284
1285   if (current_binding_level->keep == 1)
1286     keep = 1;
1287
1288   /* Get the decls in the order they were written.
1289      Usually current_binding_level->names is in reverse order.
1290      But parameter decls were previously put in forward order.  */
1291
1292   if (reverse)
1293     current_binding_level->names
1294       = decls = nreverse (current_binding_level->names);
1295   else
1296     decls = current_binding_level->names;
1297
1298   /* Output any nested inline functions within this block
1299      if they weren't already output.  */
1300   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1301     if (TREE_CODE (decl) == FUNCTION_DECL
1302         && ! TREE_ASM_WRITTEN (decl)
1303         && DECL_INITIAL (decl) != NULL_TREE
1304         && TREE_ADDRESSABLE (decl)
1305         && decl_function_context (decl) == current_function_decl)
1306       {
1307         /* If this decl was copied from a file-scope decl
1308            on account of a block-scope extern decl,
1309            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1310         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1311           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1312         else
1313           {
1314             push_function_context ();
1315             output_inline_function (decl);
1316             pop_function_context ();
1317           }
1318       }
1319
1320   /* When not in function-at-a-time mode, expand_end_bindings will
1321      warn about unused variables.  But, in function-at-a-time mode
1322      expand_end_bindings is not passed the list of variables in the
1323      current scope, and therefore no warning is emitted.  So, we
1324      explicitly warn here.  */
1325   if (!processing_template_decl)
1326     warn_about_unused_variables (getdecls ());
1327
1328   /* If there were any declarations or structure tags in that level,
1329      or if this level is a function body,
1330      create a BLOCK to record them for the life of this function.  */
1331   block = NULL_TREE;
1332   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1333   if (block_previously_created)
1334     block = current_binding_level->this_block;
1335   else if (keep == 1 || functionbody)
1336     block = make_node (BLOCK);
1337   if (block != NULL_TREE)
1338     {
1339       if (block_previously_created)
1340         {
1341           if (decls || tags || subblocks)
1342             {
1343               if (BLOCK_VARS (block))
1344                 warning ("internal compiler error: debugging info corrupted");
1345
1346               BLOCK_VARS (block) = decls;
1347
1348               /* We can have previous subblocks and new subblocks when
1349                  doing fixup_gotos with complex cleanups.  We chain the new
1350                  subblocks onto the end of any pre-existing subblocks.  */
1351               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1352                                                  subblocks);
1353             }
1354         }
1355       else
1356         {
1357           BLOCK_VARS (block) = decls;
1358           BLOCK_SUBBLOCKS (block) = subblocks;
1359         }
1360     }
1361
1362   /* In each subblock, record that this is its superior.  */
1363   if (keep >= 0)
1364     for (link = subblocks; link; link = TREE_CHAIN (link))
1365       BLOCK_SUPERCONTEXT (link) = block;
1366
1367   /* We still support the old for-scope rules, whereby the variables
1368      in a for-init statement were in scope after the for-statement
1369      ended.  We only use the new rules in flag_new_for_scope is
1370      nonzero.  */
1371   leaving_for_scope
1372     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1373
1374   /* Remove declarations for all the DECLs in this level.  */
1375   for (link = decls; link; link = TREE_CHAIN (link))
1376     {
1377       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1378         {
1379           tree outer_binding
1380             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1381           tree ns_binding;
1382
1383           if (!outer_binding)
1384             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1385           else
1386             ns_binding = NULL_TREE;
1387
1388           if (outer_binding
1389               && (BINDING_LEVEL (outer_binding)
1390                   == current_binding_level->level_chain))
1391             /* We have something like:
1392
1393                  int i;
1394                  for (int i; ;);
1395
1396                and we are leaving the `for' scope.  There's no reason to
1397                keep the binding of the inner `i' in this case.  */
1398             pop_binding (DECL_NAME (link), link);
1399           else if ((outer_binding
1400                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1401                         == TYPE_DECL))
1402                    || (ns_binding
1403                        && TREE_CODE (ns_binding) == TYPE_DECL))
1404             /* Here, we have something like:
1405
1406                  typedef int I;
1407
1408                  void f () {
1409                    for (int I; ;);
1410                  }
1411
1412                We must pop the for-scope binding so we know what's a
1413                type and what isn't.  */
1414             pop_binding (DECL_NAME (link), link);
1415           else
1416             {
1417               /* Mark this VAR_DECL as dead so that we can tell we left it
1418                  there only for backward compatibility.  */
1419               DECL_DEAD_FOR_LOCAL (link) = 1;
1420
1421               /* Keep track of what should of have happenned when we
1422                  popped the binding.  */
1423               if (outer_binding && BINDING_VALUE (outer_binding))
1424                 DECL_SHADOWED_FOR_VAR (link)
1425                   = BINDING_VALUE (outer_binding);
1426
1427               /* Add it to the list of dead variables in the next
1428                  outermost binding to that we can remove these when we
1429                  leave that binding.  */
1430               current_binding_level->level_chain->dead_vars_from_for
1431                 = tree_cons (NULL_TREE, link,
1432                              current_binding_level->level_chain->
1433                              dead_vars_from_for);
1434
1435               /* Although we don't pop the CPLUS_BINDING, we do clear
1436                  its BINDING_LEVEL since the level is going away now.  */
1437               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1438                 = 0;
1439             }
1440         }
1441       else
1442         {
1443           /* Remove the binding.  */
1444           decl = link;
1445           if (TREE_CODE (decl) == TREE_LIST)
1446             decl = TREE_VALUE (decl);
1447           if (DECL_P (decl))
1448             pop_binding (DECL_NAME (decl), decl);
1449           else if (TREE_CODE (decl) == OVERLOAD)
1450             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1451           else
1452             my_friendly_abort (0);
1453         }
1454     }
1455
1456   /* Remove declarations for any `for' variables from inner scopes
1457      that we kept around.  */
1458   for (link = current_binding_level->dead_vars_from_for;
1459        link; link = TREE_CHAIN (link))
1460     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1461
1462   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1463   for (link = current_binding_level->type_shadowed;
1464        link; link = TREE_CHAIN (link))
1465     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1466
1467   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1468   for (link = current_binding_level->shadowed_labels;
1469        link;
1470        link = TREE_CHAIN (link))
1471     pop_label (link);
1472
1473   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1474      list if a `using' declaration put them there.  The debugging
1475      back-ends won't understand OVERLOAD, so we remove them here.
1476      Because the BLOCK_VARS are (temporarily) shared with
1477      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1478      popped all the bindings.  */
1479   if (block)
1480     {
1481       tree* d;
1482
1483       for (d = &BLOCK_VARS (block); *d; )
1484         {
1485           if (TREE_CODE (*d) == TREE_LIST)
1486             *d = TREE_CHAIN (*d);
1487           else
1488             d = &TREE_CHAIN (*d);
1489         }
1490     }
1491
1492   /* If the level being exited is the top level of a function,
1493      check over all the labels.  */
1494   if (functionbody)
1495     {
1496       /* Since this is the top level block of a function, the vars are
1497          the function's parameters.  Don't leave them in the BLOCK
1498          because they are found in the FUNCTION_DECL instead.  */
1499       BLOCK_VARS (block) = 0;
1500       pop_labels (block);
1501     }
1502
1503   /* Any uses of undefined labels now operate under constraints
1504      of next binding contour.  */
1505   if (cfun)
1506     {
1507       struct binding_level *level_chain;
1508       level_chain = current_binding_level->level_chain;
1509       if (level_chain)
1510         {
1511           struct named_label_list *labels;
1512           for (labels = named_label_uses; labels; labels = labels->next)
1513             if (labels->binding_level == current_binding_level)
1514               {
1515                 labels->binding_level = level_chain;
1516                 labels->names_in_scope = level_chain->names;
1517               }
1518         }
1519     }
1520
1521   tmp = current_binding_level->keep;
1522
1523   pop_binding_level ();
1524   if (functionbody)
1525     DECL_INITIAL (current_function_decl) = block;
1526   else if (block)
1527     {
1528       if (!block_previously_created)
1529         current_binding_level->blocks
1530           = chainon (current_binding_level->blocks, block);
1531     }
1532   /* If we did not make a block for the level just exited,
1533      any blocks made for inner levels
1534      (since they cannot be recorded as subblocks in that level)
1535      must be carried forward so they will later become subblocks
1536      of something else.  */
1537   else if (subblocks)
1538     current_binding_level->blocks
1539       = chainon (current_binding_level->blocks, subblocks);
1540
1541   /* Each and every BLOCK node created here in `poplevel' is important
1542      (e.g. for proper debugging information) so if we created one
1543      earlier, mark it as "used".  */
1544   if (block)
1545     TREE_USED (block) = 1;
1546
1547   /* Take care of compiler's internal binding structures.  */
1548   if (tmp == 2)
1549     {
1550       tree scope_stmts;
1551
1552       scope_stmts
1553         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1554       if (block)
1555         {
1556           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1557           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1558         }
1559
1560       block = poplevel (keep, reverse, functionbody);
1561     }
1562
1563   return block;
1564 }
1565
1566 /* Delete the node BLOCK from the current binding level.
1567    This is used for the block inside a stmt expr ({...})
1568    so that the block can be reinserted where appropriate.  */
1569
1570 void
1571 delete_block (block)
1572      tree block;
1573 {
1574   tree t;
1575   if (current_binding_level->blocks == block)
1576     current_binding_level->blocks = TREE_CHAIN (block);
1577   for (t = current_binding_level->blocks; t;)
1578     {
1579       if (TREE_CHAIN (t) == block)
1580         TREE_CHAIN (t) = TREE_CHAIN (block);
1581       else
1582         t = TREE_CHAIN (t);
1583     }
1584   TREE_CHAIN (block) = NULL_TREE;
1585   /* Clear TREE_USED which is always set by poplevel.
1586      The flag is set again if insert_block is called.  */
1587   TREE_USED (block) = 0;
1588 }
1589
1590 /* Insert BLOCK at the end of the list of subblocks of the
1591    current binding level.  This is used when a BIND_EXPR is expanded,
1592    to handle the BLOCK node inside the BIND_EXPR.  */
1593
1594 void
1595 insert_block (block)
1596      tree block;
1597 {
1598   TREE_USED (block) = 1;
1599   current_binding_level->blocks
1600     = chainon (current_binding_level->blocks, block);
1601 }
1602
1603 /* Set the BLOCK node for the innermost scope
1604    (the one we are currently in).  */
1605
1606 void
1607 set_block (block)
1608     register tree block;
1609 {
1610   current_binding_level->this_block = block;
1611 }
1612
1613 /* Do a pushlevel for class declarations.  */
1614
1615 void
1616 pushlevel_class ()
1617 {
1618   register struct binding_level *newlevel;
1619
1620   /* Reuse or create a struct for this binding level.  */
1621 #if defined(DEBUG_CP_BINDING_LEVELS)
1622   if (0)
1623 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1624   if (free_binding_level)
1625 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1626     {
1627       newlevel = free_binding_level;
1628       free_binding_level = free_binding_level->level_chain;
1629     }
1630   else
1631     newlevel = make_binding_level ();
1632
1633 #if defined(DEBUG_CP_BINDING_LEVELS)
1634   is_class_level = 1;
1635 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1636
1637   push_binding_level (newlevel, 0, 0);
1638
1639   class_binding_level = current_binding_level;
1640   class_binding_level->parm_flag = 2;
1641   class_binding_level->this_class = current_class_type;
1642 }
1643
1644 /* ...and a poplevel for class declarations.  */
1645
1646 void
1647 poplevel_class ()
1648 {
1649   register struct binding_level *level = class_binding_level;
1650   tree shadowed;
1651
1652   my_friendly_assert (level != 0, 354);
1653
1654   /* If we're leaving a toplevel class, don't bother to do the setting
1655      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1656      shouldn't even be used when current_class_type isn't set, and second,
1657      if we don't touch it here, we're able to use the cache effect if the
1658      next time we're entering a class scope, it is the same class.  */
1659   if (current_class_depth != 1)
1660     {
1661       struct binding_level* b;
1662
1663       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1664       for (shadowed = level->class_shadowed;
1665            shadowed;
1666            shadowed = TREE_CHAIN (shadowed))
1667         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1668
1669       /* Find the next enclosing class, and recreate
1670          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1671       b = level->level_chain;
1672       while (b && b->parm_flag != 2)
1673         b = b->level_chain;
1674
1675       if (b)
1676         for (shadowed = b->class_shadowed;
1677              shadowed;
1678              shadowed = TREE_CHAIN (shadowed))
1679           {
1680             tree t;
1681
1682             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1683             while (t && BINDING_LEVEL (t) != b)
1684               t = TREE_CHAIN (t);
1685
1686             if (t)
1687               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1688                 = BINDING_VALUE (t);
1689           }
1690     }
1691   else
1692     /* Remember to save what IDENTIFIER's were bound in this scope so we
1693        can recover from cache misses.  */
1694     {
1695       previous_class_type = current_class_type;
1696       previous_class_values = class_binding_level->class_shadowed;
1697     }
1698   for (shadowed = level->type_shadowed;
1699        shadowed;
1700        shadowed = TREE_CHAIN (shadowed))
1701     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1702
1703   /* Remove the bindings for all of the class-level declarations.  */
1704   for (shadowed = level->class_shadowed;
1705        shadowed;
1706        shadowed = TREE_CHAIN (shadowed))
1707     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1708
1709   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1710                       (HOST_WIDE_INT) class_binding_level->level_chain,
1711                       class_binding_level->parm_flag,
1712                       class_binding_level->keep);
1713
1714   /* Now, pop out of the binding level which we created up in the
1715      `pushlevel_class' routine.  */
1716 #if defined(DEBUG_CP_BINDING_LEVELS)
1717   is_class_level = 1;
1718 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1719
1720   pop_binding_level ();
1721 }
1722
1723 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1724    for any names in enclosing classes.  */
1725
1726 void
1727 clear_identifier_class_values ()
1728 {
1729   tree t;
1730
1731   if (!class_binding_level)
1732     return;
1733
1734   for (t = class_binding_level->class_shadowed;
1735        t;
1736        t = TREE_CHAIN (t))
1737     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1738 }
1739
1740 /* Returns non-zero if T is a virtual function table.  */
1741
1742 int
1743 vtable_decl_p (t, data)
1744      tree t;
1745      void *data ATTRIBUTE_UNUSED;
1746 {
1747   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1748 }
1749
1750 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1751    functions.  */
1752
1753 int
1754 vtype_decl_p (t, data)
1755      tree t;
1756      void *data ATTRIBUTE_UNUSED;
1757 {
1758   return (TREE_CODE (t) == TYPE_DECL
1759           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1760           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1761 }
1762
1763 /* Return the declarations that are members of the namespace NS.  */
1764
1765 tree
1766 cp_namespace_decls (ns)
1767      tree ns;
1768 {
1769   return NAMESPACE_LEVEL (ns)->names;
1770 }
1771
1772 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1773    itself, calling F for each.  The DATA is passed to F as well.  */
1774
1775 static int
1776 walk_namespaces_r (namespace, f, data)
1777      tree namespace;
1778      walk_namespaces_fn f;
1779      void *data;
1780 {
1781   tree current;
1782   int result = 0;
1783
1784   result |= (*f) (namespace, data);
1785
1786   for (current = cp_namespace_decls (namespace);
1787        current;
1788        current = TREE_CHAIN (current))
1789     {
1790       if (TREE_CODE (current) != NAMESPACE_DECL
1791           || DECL_NAMESPACE_ALIAS (current))
1792         continue;
1793       if (!DECL_LANG_SPECIFIC (current))
1794         {
1795           /* Hmm. std. */
1796           my_friendly_assert (current == std_node, 393);
1797           continue;
1798         }
1799
1800       /* We found a namespace.  */
1801       result |= walk_namespaces_r (current, f, data);
1802     }
1803
1804   return result;
1805 }
1806
1807 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1808    F as well.  */
1809
1810 int
1811 walk_namespaces (f, data)
1812      walk_namespaces_fn f;
1813      void *data;
1814 {
1815   return walk_namespaces_r (global_namespace, f, data);
1816 }
1817
1818 struct walk_globals_data {
1819   walk_globals_pred p;
1820   walk_globals_fn f;
1821   void *data;
1822 };
1823
1824 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1825    for which P returns non-zero, call F with its address.  If any call
1826    to F returns a non-zero value, return a non-zero value.  */
1827
1828 static int
1829 walk_globals_r (namespace, data)
1830      tree namespace;
1831      void *data;
1832 {
1833   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1834   walk_globals_pred p = wgd->p;
1835   walk_globals_fn f = wgd->f;
1836   void *d = wgd->data;
1837   tree *t;
1838   int result = 0;
1839
1840   t = &NAMESPACE_LEVEL (namespace)->names;
1841
1842   while (*t)
1843     {
1844       tree glbl = *t;
1845
1846       if ((*p) (glbl, d))
1847         result |= (*f) (t, d);
1848
1849       /* If F changed *T, then *T still points at the next item to
1850          examine.  */
1851       if (*t == glbl)
1852         t = &TREE_CHAIN (*t);
1853     }
1854
1855   return result;
1856 }
1857
1858 /* Walk the global declarations.  Whenever one is found for which P
1859    returns non-zero, call F with its address.  If any call to F
1860    returns a non-zero value, return a non-zero value.  */
1861
1862 int
1863 walk_globals (p, f, data)
1864      walk_globals_pred p;
1865      walk_globals_fn f;
1866      void *data;
1867 {
1868   struct walk_globals_data wgd;
1869   wgd.p = p;
1870   wgd.f = f;
1871   wgd.data = data;
1872
1873   return walk_namespaces (walk_globals_r, &wgd);
1874 }
1875
1876 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1877    DATA is non-NULL, this is the last time we will call
1878    wrapup_global_declarations for this NAMESPACE.  */
1879
1880 int
1881 wrapup_globals_for_namespace (namespace, data)
1882      tree namespace;
1883      void *data;
1884 {
1885   tree globals = cp_namespace_decls (namespace);
1886   int len = list_length (globals);
1887   tree *vec = (tree *) alloca (sizeof (tree) * len);
1888   int i;
1889   int result;
1890   tree decl;
1891   int last_time = (data != 0);
1892
1893   if (last_time && namespace == global_namespace)
1894     /* Let compile_file handle the global namespace.  */
1895     return 0;
1896
1897   /* Process the decls in reverse order--earliest first.
1898      Put them into VEC from back to front, then take out from front.  */
1899
1900   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1901     {
1902       /* Pretend we've output an unused static variable.  This ensures
1903          that the toplevel __FUNCTION__ etc won't be emitted, unless
1904          needed. */
1905       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1906           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1907         {
1908           TREE_ASM_WRITTEN (decl) = 1;
1909           DECL_IGNORED_P (decl) = 1;
1910         }
1911       vec[len - i - 1] = decl;
1912     }
1913
1914   if (last_time)
1915     {
1916       check_global_declarations (vec, len);
1917       return 0;
1918     }
1919
1920   /* Temporarily mark vtables as external.  That prevents
1921      wrapup_global_declarations from writing them out; we must process
1922      them ourselves in finish_vtable_vardecl.  */
1923   for (i = 0; i < len; ++i)
1924     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1925       {
1926         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1927         DECL_EXTERNAL (vec[i]) = 1;
1928       }
1929
1930   /* Write out any globals that need to be output.  */
1931   result = wrapup_global_declarations (vec, len);
1932
1933   /* Undo the hack to DECL_EXTERNAL above.  */
1934   for (i = 0; i < len; ++i)
1935     if (vtable_decl_p (vec[i], /*data=*/0)
1936         && DECL_NOT_REALLY_EXTERN (vec[i]))
1937       {
1938         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1939         DECL_EXTERNAL (vec[i]) = 0;
1940       }
1941
1942   return result;
1943 }
1944
1945 \f
1946 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1947
1948 static void
1949 mark_binding_level (arg)
1950      void *arg;
1951 {
1952   struct binding_level *lvl = *(struct binding_level **)arg;
1953
1954   while (lvl)
1955     {
1956       ggc_mark_tree (lvl->names);
1957       ggc_mark_tree (lvl->tags);
1958       ggc_mark_tree (lvl->usings);
1959       ggc_mark_tree (lvl->using_directives);
1960       ggc_mark_tree (lvl->class_shadowed);
1961       ggc_mark_tree (lvl->type_shadowed);
1962       ggc_mark_tree (lvl->shadowed_labels);
1963       ggc_mark_tree (lvl->blocks);
1964       ggc_mark_tree (lvl->this_block);
1965       ggc_mark_tree (lvl->this_class);
1966       ggc_mark_tree (lvl->incomplete);
1967       ggc_mark_tree (lvl->dead_vars_from_for);
1968
1969       lvl = lvl->level_chain;
1970     }
1971 }
1972 \f
1973 /* For debugging.  */
1974 static int no_print_functions = 0;
1975 static int no_print_builtins = 0;
1976
1977 void
1978 print_binding_level (lvl)
1979      struct binding_level *lvl;
1980 {
1981   tree t;
1982   int i = 0, len;
1983   fprintf (stderr, " blocks=");
1984   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1985   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1986            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1987   if (lvl->tag_transparent)
1988     fprintf (stderr, " tag-transparent");
1989   if (lvl->more_cleanups_ok)
1990     fprintf (stderr, " more-cleanups-ok");
1991   if (lvl->have_cleanups)
1992     fprintf (stderr, " have-cleanups");
1993   fprintf (stderr, "\n");
1994   if (lvl->names)
1995     {
1996       fprintf (stderr, " names:\t");
1997       /* We can probably fit 3 names to a line?  */
1998       for (t = lvl->names; t; t = TREE_CHAIN (t))
1999         {
2000           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2001             continue;
2002           if (no_print_builtins
2003               && (TREE_CODE (t) == TYPE_DECL)
2004               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2005             continue;
2006
2007           /* Function decls tend to have longer names.  */
2008           if (TREE_CODE (t) == FUNCTION_DECL)
2009             len = 3;
2010           else
2011             len = 2;
2012           i += len;
2013           if (i > 6)
2014             {
2015               fprintf (stderr, "\n\t");
2016               i = len;
2017             }
2018           print_node_brief (stderr, "", t, 0);
2019           if (t == error_mark_node)
2020             break;
2021         }
2022       if (i)
2023         fprintf (stderr, "\n");
2024     }
2025   if (lvl->tags)
2026     {
2027       fprintf (stderr, " tags:\t");
2028       i = 0;
2029       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2030         {
2031           if (TREE_PURPOSE (t) == NULL_TREE)
2032             len = 3;
2033           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2034             len = 2;
2035           else
2036             len = 4;
2037           i += len;
2038           if (i > 5)
2039             {
2040               fprintf (stderr, "\n\t");
2041               i = len;
2042             }
2043           if (TREE_PURPOSE (t) == NULL_TREE)
2044             {
2045               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2046               fprintf (stderr, ">");
2047             }
2048           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2049             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2050           else
2051             {
2052               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2053               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2054               fprintf (stderr, ">");
2055             }
2056         }
2057       if (i)
2058         fprintf (stderr, "\n");
2059     }
2060   if (lvl->class_shadowed)
2061     {
2062       fprintf (stderr, " class-shadowed:");
2063       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2064         {
2065           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2066         }
2067       fprintf (stderr, "\n");
2068     }
2069   if (lvl->type_shadowed)
2070     {
2071       fprintf (stderr, " type-shadowed:");
2072       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2073         {
2074           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2075         }
2076       fprintf (stderr, "\n");
2077     }
2078 }
2079
2080 void
2081 print_other_binding_stack (stack)
2082      struct binding_level *stack;
2083 {
2084   struct binding_level *level;
2085   for (level = stack; level != global_binding_level; level = level->level_chain)
2086     {
2087       fprintf (stderr, "binding level ");
2088       fprintf (stderr, HOST_PTR_PRINTF, level);
2089       fprintf (stderr, "\n");
2090       print_binding_level (level);
2091     }
2092 }
2093
2094 void
2095 print_binding_stack ()
2096 {
2097   struct binding_level *b;
2098   fprintf (stderr, "current_binding_level=");
2099   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2100   fprintf (stderr, "\nclass_binding_level=");
2101   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2102   fprintf (stderr, "\nglobal_binding_level=");
2103   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2104   fprintf (stderr, "\n");
2105   if (class_binding_level)
2106     {
2107       for (b = class_binding_level; b; b = b->level_chain)
2108         if (b == current_binding_level)
2109           break;
2110       if (b)
2111         b = class_binding_level;
2112       else
2113         b = current_binding_level;
2114     }
2115   else
2116     b = current_binding_level;
2117   print_other_binding_stack (b);
2118   fprintf (stderr, "global:\n");
2119   print_binding_level (global_binding_level);
2120 }
2121
2122 /* Namespace binding access routines: The namespace_bindings field of
2123    the identifier is polymorphic, with three possible values:
2124    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2125    indicating the BINDING_VALUE of global_namespace. */
2126
2127 /* Check whether the a binding for the name to scope is known.
2128    Assumes that the bindings of the name are already a list
2129    of bindings. Returns the binding found, or NULL_TREE. */
2130
2131 static tree
2132 find_binding (name, scope)
2133      tree name;
2134      tree scope;
2135 {
2136   tree iter, prev = NULL_TREE;
2137
2138   scope = ORIGINAL_NAMESPACE (scope);
2139
2140   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2141        iter = TREE_CHAIN (iter))
2142     {
2143       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2144       if (BINDING_SCOPE (iter) == scope)
2145         {
2146           /* Move binding found to the front of the list, so
2147              subsequent lookups will find it faster. */
2148           if (prev)
2149             {
2150               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2151               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2152               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2153             }
2154           return iter;
2155         }
2156       prev = iter;
2157     }
2158   return NULL_TREE;
2159 }
2160
2161 /* Always returns a binding for name in scope. If the
2162    namespace_bindings is not a list, convert it to one first.
2163    If no binding is found, make a new one. */
2164
2165 tree
2166 binding_for_name (name, scope)
2167      tree name;
2168      tree scope;
2169 {
2170   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2171   tree result;
2172
2173   scope = ORIGINAL_NAMESPACE (scope);
2174
2175   if (b && TREE_CODE (b) != CPLUS_BINDING)
2176     {
2177       /* Get rid of optimization for global scope. */
2178       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2179       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2180       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2181     }
2182   if (b && (result = find_binding (name, scope)))
2183     return result;
2184   /* Not found, make a new one. */
2185   result = make_node (CPLUS_BINDING);
2186   TREE_CHAIN (result) = b;
2187   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2188   BINDING_SCOPE (result) = scope;
2189   BINDING_TYPE (result) = NULL_TREE;
2190   BINDING_VALUE (result) = NULL_TREE;
2191   return result;
2192 }
2193
2194 /* Return the binding value for name in scope, considering that
2195    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2196
2197 tree
2198 namespace_binding (name, scope)
2199      tree name;
2200      tree scope;
2201 {
2202   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2203   if (b == NULL_TREE)
2204     return NULL_TREE;
2205   if (scope == NULL_TREE)
2206     scope = global_namespace;
2207   if (TREE_CODE (b) != CPLUS_BINDING)
2208     return (scope == global_namespace) ? b : NULL_TREE;
2209   name = find_binding (name,scope);
2210   if (name == NULL_TREE)
2211     return name;
2212   return BINDING_VALUE (name);
2213 }
2214
2215 /* Set the binding value for name in scope. If modifying the binding
2216    of global_namespace is attempted, try to optimize it. */
2217
2218 void
2219 set_namespace_binding (name, scope, val)
2220      tree name;
2221      tree scope;
2222      tree val;
2223 {
2224   tree b;
2225
2226   if (scope == NULL_TREE)
2227     scope = global_namespace;
2228
2229   if (scope == global_namespace)
2230     {
2231       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2232       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2233         {
2234           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2235           return;
2236         }
2237     }
2238   b = binding_for_name (name, scope);
2239   BINDING_VALUE (b) = val;
2240 }
2241
2242 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2243    select a name that is unique to this compilation unit.  */
2244
2245 void
2246 push_namespace (name)
2247      tree name;
2248 {
2249   tree d = NULL_TREE;
2250   int need_new = 1;
2251   int implicit_use = 0;
2252   int global = 0;
2253   if (!global_namespace)
2254     {
2255       /* This must be ::. */
2256       my_friendly_assert (name == get_identifier ("::"), 377);
2257       global = 1;
2258     }
2259   else if (!name)
2260     {
2261       /* The name of anonymous namespace is unique for the translation
2262          unit.  */
2263       if (!anonymous_namespace_name)
2264         anonymous_namespace_name = get_file_function_name ('N');
2265       name = anonymous_namespace_name;
2266       d = IDENTIFIER_NAMESPACE_VALUE (name);
2267       if (d)
2268         /* Reopening anonymous namespace.  */
2269         need_new = 0;
2270       implicit_use = 1;
2271     }
2272   else if (current_namespace == global_namespace
2273            && name == DECL_NAME (std_node))
2274     {
2275       in_std++;
2276       return;
2277     }
2278   else
2279     {
2280       /* Check whether this is an extended namespace definition. */
2281       d = IDENTIFIER_NAMESPACE_VALUE (name);
2282       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2283         {
2284           need_new = 0;
2285           if (DECL_NAMESPACE_ALIAS (d))
2286             {
2287               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2288                         d, DECL_NAMESPACE_ALIAS (d));
2289               d = DECL_NAMESPACE_ALIAS (d);
2290             }
2291         }
2292     }
2293
2294   if (need_new)
2295     {
2296       /* Make a new namespace, binding the name to it. */
2297       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2298       /* The global namespace is not pushed, and the global binding
2299          level is set elsewhere.  */
2300       if (!global)
2301         {
2302           d = pushdecl (d);
2303           pushlevel (0);
2304           declare_namespace_level ();
2305           NAMESPACE_LEVEL (d) = current_binding_level;
2306         }
2307     }
2308   else
2309     resume_binding_level (NAMESPACE_LEVEL (d));
2310
2311   if (implicit_use)
2312     do_using_directive (d);
2313   /* Enter the name space. */
2314   current_namespace = d;
2315 }
2316
2317 /* Pop from the scope of the current namespace.  */
2318
2319 void
2320 pop_namespace ()
2321 {
2322   if (current_namespace == global_namespace)
2323     {
2324       my_friendly_assert (in_std>0, 980421);
2325       in_std--;
2326       return;
2327     }
2328   current_namespace = CP_DECL_CONTEXT (current_namespace);
2329   /* The binding level is not popped, as it might be re-opened later.  */
2330   suspend_binding_level ();
2331 }
2332
2333 /* Push into the scope of the namespace NS, even if it is deeply
2334    nested within another namespace.  */
2335
2336 void
2337 push_nested_namespace (ns)
2338      tree ns;
2339 {
2340   if (ns == global_namespace)
2341     push_to_top_level ();
2342   else
2343     {
2344       push_nested_namespace (CP_DECL_CONTEXT (ns));
2345       push_namespace (DECL_NAME (ns));
2346     }
2347 }
2348
2349 /* Pop back from the scope of the namespace NS, which was previously
2350    entered with push_nested_namespace.  */
2351
2352 void
2353 pop_nested_namespace (ns)
2354      tree ns;
2355 {
2356   while (ns != global_namespace)
2357     {
2358       pop_namespace ();
2359       ns = CP_DECL_CONTEXT (ns);
2360     }
2361
2362   pop_from_top_level ();
2363 }
2364
2365 \f
2366 /* Subroutines for reverting temporarily to top-level for instantiation
2367    of templates and such.  We actually need to clear out the class- and
2368    local-value slots of all identifiers, so that only the global values
2369    are at all visible.  Simply setting current_binding_level to the global
2370    scope isn't enough, because more binding levels may be pushed.  */
2371 struct saved_scope *scope_chain;
2372
2373 /* Mark ST for GC.  */
2374
2375 static void
2376 mark_stmt_tree (st)
2377      struct stmt_tree *st;
2378 {
2379   ggc_mark_tree (st->x_last_stmt);
2380   ggc_mark_tree (st->x_last_expr_type);
2381 }
2382
2383 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2384
2385 static void
2386 mark_saved_scope (arg)
2387      void *arg;
2388 {
2389   struct saved_scope *t = *(struct saved_scope **)arg;
2390   while (t)
2391     {
2392       mark_binding_level (&t->class_bindings);
2393       ggc_mark_tree (t->old_bindings);
2394       ggc_mark_tree (t->old_namespace);
2395       ggc_mark_tree (t->class_name);
2396       ggc_mark_tree (t->class_type);
2397       ggc_mark_tree (t->access_specifier);
2398       ggc_mark_tree (t->function_decl);
2399       if (t->lang_base)
2400         ggc_mark_tree_varray (t->lang_base);
2401       ggc_mark_tree (t->lang_name);
2402       ggc_mark_tree (t->x_function_parms);
2403       ggc_mark_tree (t->template_parms);
2404       ggc_mark_tree (t->x_previous_class_type);
2405       ggc_mark_tree (t->x_previous_class_values);
2406       ggc_mark_tree (t->x_saved_tree);
2407       ggc_mark_tree (t->incomplete);
2408       ggc_mark_tree (t->lookups);
2409
2410       mark_stmt_tree (&t->x_stmt_tree);
2411       mark_binding_level (&t->bindings);
2412       t = t->prev;
2413     }
2414 }
2415
2416 static tree
2417 store_bindings (names, old_bindings)
2418      tree names, old_bindings;
2419 {
2420   tree t;
2421   for (t = names; t; t = TREE_CHAIN (t))
2422     {
2423       tree binding, t1, id;
2424
2425       if (TREE_CODE (t) == TREE_LIST)
2426         id = TREE_PURPOSE (t);
2427       else
2428         id = DECL_NAME (t);
2429
2430       if (!id
2431           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2432              we have no IDENTIFIER_BINDING if we have left the class
2433              scope, but cached the class-level declarations.  */
2434           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2435         continue;
2436
2437       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2438         if (TREE_VEC_ELT (t1, 0) == id)
2439           goto skip_it;
2440
2441       binding = make_tree_vec (4);
2442
2443       if (id)
2444         {
2445           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2446           TREE_VEC_ELT (binding, 0) = id;
2447           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2448           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2449           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2450           IDENTIFIER_BINDING (id) = NULL_TREE;
2451           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2452         }
2453       TREE_CHAIN (binding) = old_bindings;
2454       old_bindings = binding;
2455     skip_it:
2456       ;
2457     }
2458   return old_bindings;
2459 }
2460
2461 void
2462 maybe_push_to_top_level (pseudo)
2463      int pseudo;
2464 {
2465   struct saved_scope *s;
2466   struct binding_level *b;
2467   tree old_bindings;
2468   int need_pop;
2469
2470   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2471
2472   b = scope_chain ? current_binding_level : 0;
2473
2474   /* If we're in the middle of some function, save our state.  */
2475   if (cfun)
2476     {
2477       need_pop = 1;
2478       push_function_context_to (NULL_TREE);
2479     }
2480   else
2481     need_pop = 0;
2482
2483   old_bindings = NULL_TREE;
2484   if (scope_chain && previous_class_type)
2485     old_bindings = store_bindings (previous_class_values, old_bindings);
2486
2487   /* Have to include global_binding_level, because class-level decls
2488      aren't listed anywhere useful.  */
2489   for (; b; b = b->level_chain)
2490     {
2491       tree t;
2492
2493       /* Template IDs are inserted into the global level. If they were
2494          inserted into namespace level, finish_file wouldn't find them
2495          when doing pending instantiations. Therefore, don't stop at
2496          namespace level, but continue until :: .  */
2497       if (b == global_binding_level || (pseudo && b->template_parms_p))
2498         break;
2499
2500       old_bindings = store_bindings (b->names, old_bindings);
2501       /* We also need to check class_shadowed to save class-level type
2502          bindings, since pushclass doesn't fill in b->names.  */
2503       if (b->parm_flag == 2)
2504         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2505
2506       /* Unwind type-value slots back to top level.  */
2507       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2508         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2509     }
2510   s->prev = scope_chain;
2511   s->old_bindings = old_bindings;
2512   s->bindings = b;
2513   s->need_pop_function_context = need_pop;
2514   s->function_decl = current_function_decl;
2515
2516   scope_chain = s;
2517   current_function_decl = NULL_TREE;
2518   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2519   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2520   current_lang_name = lang_name_cplusplus;
2521   strict_prototype = strict_prototypes_lang_cplusplus;
2522   current_namespace = global_namespace;
2523 }
2524
2525 void
2526 push_to_top_level ()
2527 {
2528   maybe_push_to_top_level (0);
2529 }
2530
2531 void
2532 pop_from_top_level ()
2533 {
2534   struct saved_scope *s = scope_chain;
2535   tree t;
2536
2537   /* Clear out class-level bindings cache.  */
2538   if (previous_class_type)
2539     invalidate_class_lookup_cache ();
2540
2541   VARRAY_FREE (current_lang_base);
2542
2543   scope_chain = s->prev;
2544   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2545     {
2546       tree id = TREE_VEC_ELT (t, 0);
2547       if (id)
2548         {
2549           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2550           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2551           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2552         }
2553     }
2554
2555   if (current_lang_name == lang_name_cplusplus)
2556     strict_prototype = strict_prototypes_lang_cplusplus;
2557   else if (current_lang_name == lang_name_c)
2558     strict_prototype = strict_prototypes_lang_c;
2559
2560   /* If we were in the middle of compiling a function, restore our
2561      state.  */
2562   if (s->need_pop_function_context)
2563     pop_function_context_from (NULL_TREE);
2564   current_function_decl = s->function_decl;
2565
2566   free (s);
2567 }
2568 \f
2569 /* Push a definition of struct, union or enum tag "name".
2570    into binding_level "b".   "type" should be the type node,
2571    We assume that the tag "name" is not already defined.
2572
2573    Note that the definition may really be just a forward reference.
2574    In that case, the TYPE_SIZE will be a NULL_TREE.
2575
2576    C++ gratuitously puts all these tags in the name space.  */
2577
2578 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2579    record the shadowed value for this binding contour.  TYPE is
2580    the type that ID maps to.  */
2581
2582 static void
2583 set_identifier_type_value_with_scope (id, type, b)
2584      tree id;
2585      tree type;
2586      struct binding_level *b;
2587 {
2588   if (!b->namespace_p)
2589     {
2590       /* Shadow the marker, not the real thing, so that the marker
2591          gets restored later. */
2592       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2593       b->type_shadowed
2594         = tree_cons (id, old_type_value, b->type_shadowed);
2595     }
2596   else
2597     {
2598       tree binding = binding_for_name (id, current_namespace);
2599       BINDING_TYPE (binding) = type;
2600       /* Store marker instead of real type. */
2601       type = global_type_node;
2602     }
2603   SET_IDENTIFIER_TYPE_VALUE (id, type);
2604 }
2605
2606 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2607
2608 void
2609 set_identifier_type_value (id, type)
2610      tree id;
2611      tree type;
2612 {
2613   set_identifier_type_value_with_scope (id, type, current_binding_level);
2614 }
2615
2616 /* Return the type associated with id. */
2617
2618 tree
2619 identifier_type_value (id)
2620      tree id;
2621 {
2622   /* There is no type with that name, anywhere. */
2623   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2624     return NULL_TREE;
2625   /* This is not the type marker, but the real thing. */
2626   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2627     return REAL_IDENTIFIER_TYPE_VALUE (id);
2628   /* Have to search for it. It must be on the global level, now.
2629      Ask lookup_name not to return non-types. */
2630   id = lookup_name_real (id, 2, 1, 0);
2631   if (id)
2632     return TREE_TYPE (id);
2633   return NULL_TREE;
2634 }
2635
2636 /* Pop off extraneous binding levels left over due to syntax errors.
2637
2638    We don't pop past namespaces, as they might be valid.  */
2639
2640 void
2641 pop_everything ()
2642 {
2643 #ifdef DEBUG_CP_BINDING_LEVELS
2644   fprintf (stderr, "XXX entering pop_everything ()\n");
2645 #endif
2646   while (!toplevel_bindings_p ())
2647     {
2648       if (current_binding_level->parm_flag == 2)
2649         pop_nested_class ();
2650       else
2651         poplevel (0, 0, 0);
2652     }
2653 #ifdef DEBUG_CP_BINDING_LEVELS
2654   fprintf (stderr, "XXX leaving pop_everything ()\n");
2655 #endif
2656 }
2657
2658 /* The type TYPE is being declared.  If it is a class template, or a
2659    specialization of a class template, do any processing required and
2660    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2661    being declared a friend.  B is the binding level at which this TYPE
2662    should be bound.
2663
2664    Returns the TYPE_DECL for TYPE, which may have been altered by this
2665    processing.  */
2666
2667 static tree
2668 maybe_process_template_type_declaration (type, globalize, b)
2669      tree type;
2670      int globalize;
2671      struct binding_level* b;
2672 {
2673   tree decl = TYPE_NAME (type);
2674
2675   if (processing_template_parmlist)
2676     /* You can't declare a new template type in a template parameter
2677        list.  But, you can declare a non-template type:
2678
2679          template <class A*> struct S;
2680
2681        is a forward-declaration of `A'.  */
2682     ;
2683   else
2684     {
2685       maybe_check_template_type (type);
2686
2687       my_friendly_assert (IS_AGGR_TYPE (type)
2688                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2689
2690
2691       if (processing_template_decl)
2692         {
2693           /* This may change after the call to
2694              push_template_decl_real, but we want the original value.  */
2695           tree name = DECL_NAME (decl);
2696
2697           decl = push_template_decl_real (decl, globalize);
2698           /* If the current binding level is the binding level for the
2699              template parameters (see the comment in
2700              begin_template_parm_list) and the enclosing level is a class
2701              scope, and we're not looking at a friend, push the
2702              declaration of the member class into the class scope.  In the
2703              friend case, push_template_decl will already have put the
2704              friend into global scope, if appropriate.  */
2705           if (TREE_CODE (type) != ENUMERAL_TYPE
2706               && !globalize && b->template_parms_p
2707               && b->level_chain->parm_flag == 2)
2708             {
2709               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2710               /* Put this tag on the list of tags for the class, since
2711                  that won't happen below because B is not the class
2712                  binding level, but is instead the pseudo-global level.  */
2713               b->level_chain->tags =
2714                 tree_cons (name, type, b->level_chain->tags);
2715               if (!COMPLETE_TYPE_P (current_class_type))
2716                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2717             }
2718         }
2719     }
2720
2721   return decl;
2722 }
2723
2724 /* In C++, you don't have to write `struct S' to refer to `S'; you
2725    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2726    if the user had written `typedef struct S S'.  Create and return
2727    the TYPE_DECL for TYPE.  */
2728
2729 tree
2730 create_implicit_typedef (name, type)
2731      tree name;
2732      tree type;
2733 {
2734   tree decl;
2735
2736   decl = build_decl (TYPE_DECL, name, type);
2737   SET_DECL_ARTIFICIAL (decl);
2738   /* There are other implicit type declarations, like the one *within*
2739      a class that allows you to write `S::S'.  We must distinguish
2740      amongst these.  */
2741   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2742   TYPE_NAME (type) = decl;
2743
2744   return decl;
2745 }
2746
2747 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2748    Normally put it into the inner-most non-tag-transparent scope,
2749    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2750    The latter is needed for implicit declarations.  */
2751
2752 void
2753 pushtag (name, type, globalize)
2754      tree name, type;
2755      int globalize;
2756 {
2757   register struct binding_level *b;
2758
2759   b = current_binding_level;
2760   while (b->tag_transparent
2761          || (globalize && b->parm_flag == 2))
2762     b = b->level_chain;
2763
2764   b->tags = tree_cons (name, type, b->tags);
2765
2766   if (name)
2767     {
2768       /* Do C++ gratuitous typedefing.  */
2769       if (IDENTIFIER_TYPE_VALUE (name) != type)
2770         {
2771           register tree d = NULL_TREE;
2772           int in_class = 0;
2773           tree context = TYPE_CONTEXT (type);
2774
2775           if (! context)
2776             {
2777               tree cs = current_scope ();
2778
2779               if (! globalize)
2780                 context = cs;
2781               else if (cs != NULL_TREE && TYPE_P (cs))
2782                 /* When declaring a friend class of a local class, we want
2783                    to inject the newly named class into the scope
2784                    containing the local class, not the namespace scope.  */
2785                 context = decl_function_context (get_type_decl (cs));
2786             }
2787           if (!context)
2788             context = current_namespace;
2789
2790           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2791               || b->parm_flag == 2)
2792             in_class = 1;
2793
2794           if (current_lang_name == lang_name_java)
2795             TYPE_FOR_JAVA (type) = 1;
2796
2797           d = create_implicit_typedef (name, type);
2798           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2799           if (! in_class)
2800             set_identifier_type_value_with_scope (name, type, b);
2801
2802           d = maybe_process_template_type_declaration (type,
2803                                                        globalize, b);
2804
2805           if (b->parm_flag == 2)
2806             {
2807               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2808                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2809                    class.  But if it's a member template class, we
2810                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2811                    is done later.  */
2812                 finish_member_declaration (d);
2813               else
2814                 pushdecl_class_level (d);
2815             }
2816           else
2817             d = pushdecl_with_scope (d, b);
2818
2819           if (ANON_AGGRNAME_P (name))
2820             DECL_IGNORED_P (d) = 1;
2821
2822           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2823           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2824           if (!uses_template_parms (type))
2825             DECL_ASSEMBLER_NAME (d)
2826               = get_identifier (build_overload_name (type, 1, 1));
2827         }
2828       if (b->parm_flag == 2)
2829         {
2830           if (!COMPLETE_TYPE_P (current_class_type))
2831             CLASSTYPE_TAGS (current_class_type) = b->tags;
2832         }
2833     }
2834
2835   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2836     /* Use the canonical TYPE_DECL for this node.  */
2837     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2838   else
2839     {
2840       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2841          will be the tagged type we just added to the current
2842          binding level.  This fake NULL-named TYPE_DECL node helps
2843          dwarfout.c to know when it needs to output a
2844          representation of a tagged type, and it also gives us a
2845          convenient place to record the "scope start" address for
2846          the tagged type.  */
2847
2848       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2849       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2850     }
2851 }
2852
2853 /* Counter used to create anonymous type names.  */
2854
2855 static int anon_cnt = 0;
2856
2857 /* Return an IDENTIFIER which can be used as a name for
2858    anonymous structs and unions.  */
2859
2860 tree
2861 make_anon_name ()
2862 {
2863   char buf[32];
2864
2865   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2866   return get_identifier (buf);
2867 }
2868
2869 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2870    This keeps dbxout from getting confused.  */
2871
2872 void
2873 clear_anon_tags ()
2874 {
2875   register struct binding_level *b;
2876   register tree tags;
2877   static int last_cnt = 0;
2878
2879   /* Fast out if no new anon names were declared.  */
2880   if (last_cnt == anon_cnt)
2881     return;
2882
2883   b = current_binding_level;
2884   while (b->tag_transparent)
2885     b = b->level_chain;
2886   tags = b->tags;
2887   while (tags)
2888     {
2889       /* A NULL purpose means we have already processed all tags
2890          from here to the end of the list.  */
2891       if (TREE_PURPOSE (tags) == NULL_TREE)
2892         break;
2893       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2894         TREE_PURPOSE (tags) = NULL_TREE;
2895       tags = TREE_CHAIN (tags);
2896     }
2897   last_cnt = anon_cnt;
2898 }
2899 \f
2900 /* Subroutine of duplicate_decls: return truthvalue of whether
2901    or not types of these decls match.
2902
2903    For C++, we must compare the parameter list so that `int' can match
2904    `int&' in a parameter position, but `int&' is not confused with
2905    `const int&'.  */
2906
2907 int
2908 decls_match (newdecl, olddecl)
2909      tree newdecl, olddecl;
2910 {
2911   int types_match;
2912
2913   if (newdecl == olddecl)
2914     return 1;
2915
2916   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2917     /* If the two DECLs are not even the same kind of thing, we're not
2918        interested in their types.  */
2919     return 0;
2920
2921   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2922     {
2923       tree f1 = TREE_TYPE (newdecl);
2924       tree f2 = TREE_TYPE (olddecl);
2925       tree p1 = TYPE_ARG_TYPES (f1);
2926       tree p2 = TYPE_ARG_TYPES (f2);
2927
2928       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2929           && ! (DECL_EXTERN_C_P (newdecl)
2930                 && DECL_EXTERN_C_P (olddecl)))
2931         return 0;
2932
2933       if (TREE_CODE (f1) != TREE_CODE (f2))
2934         return 0;
2935
2936       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2937         {
2938           if ((! strict_prototypes_lang_c || DECL_BUILT_IN (olddecl))
2939               && DECL_EXTERN_C_P (olddecl)
2940               && p2 == NULL_TREE)
2941             {
2942               types_match = self_promoting_args_p (p1);
2943               if (p1 == void_list_node)
2944                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2945             }
2946           else if (!strict_prototypes_lang_c
2947                    && DECL_EXTERN_C_P (olddecl)
2948                    && DECL_EXTERN_C_P (newdecl)
2949                    && p1 == NULL_TREE)
2950             {
2951               types_match = self_promoting_args_p (p2);
2952               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2953             }
2954           else
2955             types_match = compparms (p1, p2);
2956         }
2957       else
2958         types_match = 0;
2959     }
2960   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2961     {
2962       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2963                                 DECL_TEMPLATE_PARMS (olddecl)))
2964         return 0;
2965
2966       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2967         types_match = 1;
2968       else
2969         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2970                                    DECL_TEMPLATE_RESULT (newdecl));
2971     }
2972   else
2973     {
2974       if (TREE_TYPE (newdecl) == error_mark_node)
2975         types_match = TREE_TYPE (olddecl) == error_mark_node;
2976       else if (TREE_TYPE (olddecl) == NULL_TREE)
2977         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2978       else if (TREE_TYPE (newdecl) == NULL_TREE)
2979         types_match = 0;
2980       else
2981         types_match = comptypes (TREE_TYPE (newdecl),
2982                                  TREE_TYPE (olddecl),
2983                                  COMPARE_REDECLARATION);
2984     }
2985
2986   return types_match;
2987 }
2988
2989 /* If NEWDECL is `static' and an `extern' was seen previously,
2990    warn about it.  OLDDECL is the previous declaration.
2991
2992    Note that this does not apply to the C++ case of declaring
2993    a variable `extern const' and then later `const'.
2994
2995    Don't complain about built-in functions, since they are beyond
2996    the user's control.  */
2997
2998 static void
2999 warn_extern_redeclared_static (newdecl, olddecl)
3000      tree newdecl, olddecl;
3001 {
3002   static const char *explicit_extern_static_warning
3003     = "`%D' was declared `extern' and later `static'";
3004   static const char *implicit_extern_static_warning
3005     = "`%D' was declared implicitly `extern' and later `static'";
3006
3007   tree name;
3008
3009   if (TREE_CODE (newdecl) == TYPE_DECL
3010       || TREE_CODE (newdecl) == TEMPLATE_DECL)
3011     return;
3012
3013   /* Don't get confused by static member functions; that's a different
3014      use of `static'.  */
3015   if (TREE_CODE (newdecl) == FUNCTION_DECL
3016       && DECL_STATIC_FUNCTION_P (newdecl))
3017     return;
3018
3019   /* If the old declaration was `static', or the new one isn't, then
3020      then everything is OK.  */
3021   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3022     return;
3023
3024   /* It's OK to declare a builtin function as `static'.  */
3025   if (TREE_CODE (olddecl) == FUNCTION_DECL
3026       && DECL_ARTIFICIAL (olddecl))
3027     return;
3028
3029   name = DECL_ASSEMBLER_NAME (newdecl);
3030   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3031               ? implicit_extern_static_warning
3032               : explicit_extern_static_warning, newdecl);
3033   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3034 }
3035
3036 /* Handle when a new declaration NEWDECL has the same name as an old
3037    one OLDDECL in the same binding contour.  Prints an error message
3038    if appropriate.
3039
3040    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3041    Otherwise, return 0.  */
3042
3043 int
3044 duplicate_decls (newdecl, olddecl)
3045      tree newdecl, olddecl;
3046 {
3047   unsigned olddecl_uid = DECL_UID (olddecl);
3048   int olddecl_friend = 0, types_match = 0;
3049   int new_defines_function = 0;
3050
3051   if (newdecl == olddecl)
3052     return 1;
3053
3054   types_match = decls_match (newdecl, olddecl);
3055
3056   /* If either the type of the new decl or the type of the old decl is an
3057      error_mark_node, then that implies that we have already issued an
3058      error (earlier) for some bogus type specification, and in that case,
3059      it is rather pointless to harass the user with yet more error message
3060      about the same declaration, so just pretend the types match here.  */
3061   if (TREE_TYPE (newdecl) == error_mark_node
3062       || TREE_TYPE (olddecl) == error_mark_node)
3063     types_match = 1;
3064
3065   /* Check for redeclaration and other discrepancies. */
3066   if (TREE_CODE (olddecl) == FUNCTION_DECL
3067       && DECL_ARTIFICIAL (olddecl))
3068     {
3069       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3070         {
3071           /* If you declare a built-in or predefined function name as static,
3072              the old definition is overridden, but optionally warn this was a
3073              bad choice of name.  */
3074           if (! TREE_PUBLIC (newdecl))
3075             {
3076               if (warn_shadow)
3077                 cp_warning ("shadowing %s function `%#D'",
3078                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3079                             olddecl);
3080               /* Discard the old built-in function.  */
3081               return 0;
3082             }
3083           /* If the built-in is not ansi, then programs can override
3084              it even globally without an error.  */
3085           else if (! DECL_BUILT_IN (olddecl))
3086             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3087                         olddecl, newdecl);
3088           else
3089             {
3090               cp_error ("declaration of `%#D'", newdecl);
3091               cp_error ("conflicts with built-in declaration `%#D'",
3092                         olddecl);
3093             }
3094           return 0;
3095         }
3096       else if (!types_match)
3097         {
3098           if ((DECL_EXTERN_C_P (newdecl)
3099                && DECL_EXTERN_C_P (olddecl))
3100               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3101                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3102             {
3103               /* A near match; override the builtin.  */
3104
3105               if (TREE_PUBLIC (newdecl))
3106                 {
3107                   cp_warning ("new declaration `%#D'", newdecl);
3108                   cp_warning ("ambiguates built-in declaration `%#D'",
3109                               olddecl);
3110                 }
3111               else if (warn_shadow)
3112                 cp_warning ("shadowing %s function `%#D'",
3113                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3114                             olddecl);
3115             }
3116           else
3117             /* Discard the old built-in function.  */
3118             return 0;
3119         }
3120
3121       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3122         {
3123           /* If a builtin function is redeclared as `static', merge
3124              the declarations, but make the original one static.  */
3125           DECL_THIS_STATIC (olddecl) = 1;
3126           TREE_PUBLIC (olddecl) = 0;
3127
3128           /* Make the old declaration consistent with the new one so
3129              that all remnants of the builtin-ness of this function
3130              will be banished.  */
3131           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3132           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3133           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3134           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3135                                        newdecl);
3136         }
3137     }
3138   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3139     {
3140       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3141            && TREE_CODE (newdecl) != TYPE_DECL
3142            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3143                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3144           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3145               && TREE_CODE (olddecl) != TYPE_DECL
3146               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3147                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3148                         == TYPE_DECL))))
3149         {
3150           /* We do nothing special here, because C++ does such nasty
3151              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3152              get shadowed, and know that if we need to find a TYPE_DECL
3153              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3154              slot of the identifier.  */
3155           return 0;
3156         }
3157
3158       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3159            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3160           || (TREE_CODE (olddecl) == FUNCTION_DECL
3161               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3162         return 0;
3163
3164       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3165       if (TREE_CODE (olddecl) == TREE_LIST)
3166         olddecl = TREE_VALUE (olddecl);
3167       cp_error_at ("previous declaration of `%#D'", olddecl);
3168
3169       /* New decl is completely inconsistent with the old one =>
3170          tell caller to replace the old one.  */
3171
3172       return 0;
3173     }
3174   else if (!types_match)
3175     {
3176       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3177         /* These are certainly not duplicate declarations; they're
3178            from different scopes.  */
3179         return 0;
3180
3181       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3182         {
3183           /* The name of a class template may not be declared to refer to
3184              any other template, class, function, object, namespace, value,
3185              or type in the same scope.  */
3186           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3187               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3188             {
3189               cp_error ("declaration of template `%#D'", newdecl);
3190               cp_error_at ("conflicts with previous declaration `%#D'",
3191                            olddecl);
3192             }
3193           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3194                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3195                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3196                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3197                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3198                                            DECL_TEMPLATE_PARMS (olddecl)))
3199             {
3200               cp_error ("new declaration `%#D'", newdecl);
3201               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3202             }
3203           return 0;
3204         }
3205       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3206         {
3207           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3208             {
3209               cp_error ("declaration of C function `%#D' conflicts with",
3210                         newdecl);
3211               cp_error_at ("previous declaration `%#D' here", olddecl);
3212             }
3213           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3214                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3215             {
3216               cp_error ("new declaration `%#D'", newdecl);
3217               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3218             }
3219           else
3220             return 0;
3221         }
3222
3223       /* Already complained about this, so don't do so again.  */
3224       else if (current_class_type == NULL_TREE
3225           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3226         {
3227           cp_error ("conflicting types for `%#D'", newdecl);
3228           cp_error_at ("previous declaration as `%#D'", olddecl);
3229         }
3230     }
3231   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3232             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3233                  && (!DECL_TEMPLATE_INFO (newdecl)
3234                      || (DECL_TI_TEMPLATE (newdecl)
3235                          != DECL_TI_TEMPLATE (olddecl))))
3236                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3237                     && (!DECL_TEMPLATE_INFO (olddecl)
3238                         || (DECL_TI_TEMPLATE (olddecl)
3239                             != DECL_TI_TEMPLATE (newdecl))))))
3240     /* It's OK to have a template specialization and a non-template
3241        with the same type, or to have specializations of two
3242        different templates with the same type.  Note that if one is a
3243        specialization, and the other is an instantiation of the same
3244        template, that we do not exit at this point.  That situation
3245        can occur if we instantiate a template class, and then
3246        specialize one of its methods.  This situation is legal, but
3247        the declarations must be merged in the usual way.  */
3248     return 0;
3249   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3250            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3251                 && !DECL_USE_TEMPLATE (newdecl))
3252                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3253                    && !DECL_USE_TEMPLATE (olddecl))))
3254     /* One of the declarations is a template instantiation, and the
3255        other is not a template at all.  That's OK.  */
3256     return 0;
3257   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3258            && DECL_NAMESPACE_ALIAS (newdecl)
3259            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3260     /* Redeclaration of namespace alias, ignore it. */
3261     return 1;
3262   else
3263     {
3264       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3265       if (errmsg)
3266         {
3267           cp_error (errmsg, newdecl);
3268           if (DECL_NAME (olddecl) != NULL_TREE)
3269             cp_error_at ((DECL_INITIAL (olddecl)
3270                           && namespace_bindings_p ())
3271                          ? "`%#D' previously defined here"
3272                          : "`%#D' previously declared here", olddecl);
3273         }
3274       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3275                && DECL_INITIAL (olddecl) != NULL_TREE
3276                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3277                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3278         {
3279           /* Prototype decl follows defn w/o prototype.  */
3280           cp_warning_at ("prototype for `%#D'", newdecl);
3281           cp_warning_at ("follows non-prototype definition here", olddecl);
3282         }
3283       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3284                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3285         {
3286           /* extern "C" int foo ();
3287              int foo () { bar (); }
3288              is OK.  */
3289           if (current_lang_stack
3290               == &VARRAY_TREE (current_lang_base, 0))
3291             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3292           else
3293             {
3294               cp_error_at ("previous declaration of `%#D' with %L linkage",
3295                            olddecl, DECL_LANGUAGE (olddecl));
3296               cp_error ("conflicts with new declaration with %L linkage",
3297                         DECL_LANGUAGE (newdecl));
3298             }
3299         }
3300
3301       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3302         ;
3303       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3304         {
3305           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3306           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3307           int i = 1;
3308
3309           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3310             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3311
3312           for (; t1 && t1 != void_list_node;
3313                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3314             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3315               {
3316                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3317                                            TREE_PURPOSE (t2)))
3318                   {
3319                     if (pedantic)
3320                       {
3321                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3322                                     i, newdecl);
3323                         cp_pedwarn_at ("after previous specification in `%#D'",
3324                                        olddecl);
3325                       }
3326                   }
3327                 else
3328                   {
3329                     cp_error ("default argument given for parameter %d of `%#D'",
3330                               i, newdecl);
3331                     cp_error_at ("after previous specification in `%#D'",
3332                                  olddecl);
3333                   }
3334               }
3335
3336           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3337               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3338             {
3339               cp_warning ("`%#D' was used before it was declared inline",
3340                           newdecl);
3341               cp_warning_at ("previous non-inline declaration here",
3342                              olddecl);
3343             }
3344         }
3345     }
3346
3347   /* If new decl is `static' and an `extern' was seen previously,
3348      warn about it.  */
3349   warn_extern_redeclared_static (newdecl, olddecl);
3350
3351   /* We have committed to returning 1 at this point.  */
3352   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3353     {
3354       /* Now that functions must hold information normally held
3355          by field decls, there is extra work to do so that
3356          declaration information does not get destroyed during
3357          definition.  */
3358       if (DECL_VINDEX (olddecl))
3359         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3360       if (DECL_VIRTUAL_CONTEXT (olddecl))
3361         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3362       if (DECL_CONTEXT (olddecl))
3363         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3364       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3365         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3366       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3367       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3368       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3369       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3370       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3371       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3372       DECL_VTT_PARM (newdecl) = DECL_VTT_PARM (olddecl);
3373       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3374
3375       /* Optionally warn about more than one declaration for the same
3376          name, but don't warn about a function declaration followed by a
3377          definition.  */
3378       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3379           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3380           /* Don't warn about extern decl followed by definition. */
3381           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3382           /* Don't warn about friends, let add_friend take care of it. */
3383           && ! DECL_FRIEND_P (newdecl))
3384         {
3385           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3386           cp_warning_at ("previous declaration of `%D'", olddecl);
3387         }
3388     }
3389
3390   /* Deal with C++: must preserve virtual function table size.  */
3391   if (TREE_CODE (olddecl) == TYPE_DECL)
3392     {
3393       register tree newtype = TREE_TYPE (newdecl);
3394       register tree oldtype = TREE_TYPE (olddecl);
3395
3396       if (newtype != error_mark_node && oldtype != error_mark_node
3397           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3398         {
3399           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3400           CLASSTYPE_FRIEND_CLASSES (newtype)
3401             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3402         }
3403     }
3404
3405   /* Copy all the DECL_... slots specified in the new decl
3406      except for any that we copy here from the old type.  */
3407   DECL_MACHINE_ATTRIBUTES (newdecl)
3408     = merge_machine_decl_attributes (olddecl, newdecl);
3409
3410   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3411     {
3412       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3413                              DECL_TEMPLATE_RESULT (olddecl)))
3414         cp_error ("invalid redeclaration of %D", newdecl);
3415       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3416       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3417         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3418                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3419
3420       return 1;
3421     }
3422
3423   if (types_match)
3424     {
3425       /* Automatically handles default parameters.  */
3426       tree oldtype = TREE_TYPE (olddecl);
3427       tree newtype;
3428
3429       /* Merge the data types specified in the two decls.  */
3430       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3431
3432       if (TREE_CODE (newdecl) == VAR_DECL)
3433         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3434       /* Do this after calling `common_type' so that default
3435          parameters don't confuse us.  */
3436       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3437           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3438               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3439         {
3440           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3441                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3442           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3443                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3444
3445           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3446               && DECL_SOURCE_LINE (olddecl) != 0
3447               && flag_exceptions
3448               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3449                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3450             {
3451               cp_error ("declaration of `%F' throws different exceptions",
3452                         newdecl);
3453               cp_error_at ("than previous declaration `%F'", olddecl);
3454             }
3455         }
3456       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3457
3458       /* Lay the type out, unless already done.  */
3459       if (! same_type_p (newtype, oldtype)
3460           && TREE_TYPE (newdecl) != error_mark_node
3461           && !(processing_template_decl && uses_template_parms (newdecl)))
3462         layout_type (TREE_TYPE (newdecl));
3463
3464       if ((TREE_CODE (newdecl) == VAR_DECL
3465            || TREE_CODE (newdecl) == PARM_DECL
3466            || TREE_CODE (newdecl) == RESULT_DECL
3467            || TREE_CODE (newdecl) == FIELD_DECL
3468            || TREE_CODE (newdecl) == TYPE_DECL)
3469           && !(processing_template_decl && uses_template_parms (newdecl)))
3470         layout_decl (newdecl, 0);
3471
3472       /* Merge the type qualifiers.  */
3473       if (TREE_READONLY (newdecl))
3474         TREE_READONLY (olddecl) = 1;
3475       if (TREE_THIS_VOLATILE (newdecl))
3476         TREE_THIS_VOLATILE (olddecl) = 1;
3477
3478       /* Merge the initialization information.  */
3479       if (DECL_INITIAL (newdecl) == NULL_TREE
3480           && DECL_INITIAL (olddecl) != NULL_TREE)
3481         {
3482           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3483           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3484           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3485           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3486               && DECL_LANG_SPECIFIC (newdecl)
3487               && DECL_LANG_SPECIFIC (olddecl))
3488             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3489         }
3490
3491       /* Merge the section attribute.
3492          We want to issue an error if the sections conflict but that must be
3493          done later in decl_attributes since we are called before attributes
3494          are assigned.  */
3495       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3496         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3497
3498       /* Keep the old rtl since we can safely use it.  */
3499       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3500
3501       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3502         {
3503           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3504             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3505           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3506             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3507           DECL_NO_LIMIT_STACK (newdecl)
3508             |= DECL_NO_LIMIT_STACK (olddecl);
3509         }
3510     }
3511   /* If cannot merge, then use the new type and qualifiers,
3512      and don't preserve the old rtl.  */
3513   else
3514     {
3515       /* Clean out any memory we had of the old declaration.  */
3516       tree oldstatic = value_member (olddecl, static_aggregates);
3517       if (oldstatic)
3518         TREE_VALUE (oldstatic) = error_mark_node;
3519
3520       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3521       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3522       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3523       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3524     }
3525
3526   /* Merge the storage class information.  */
3527   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3528   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3529   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3530   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3531   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3532   if (! DECL_EXTERNAL (olddecl))
3533     DECL_EXTERNAL (newdecl) = 0;
3534
3535   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3536     {
3537       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3538       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3539       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3540       DECL_TEMPLATE_INSTANTIATED (newdecl)
3541         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3542       /* Don't really know how much of the language-specific
3543          values we should copy from old to new.  */
3544       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3545       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3546       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3547       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3548       olddecl_friend = DECL_FRIEND_P (olddecl);
3549
3550       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3551       if (TREE_CODE (newdecl) == FUNCTION_DECL
3552           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3553         DECL_BEFRIENDING_CLASSES (newdecl)
3554           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3555                      DECL_BEFRIENDING_CLASSES (olddecl));
3556     }
3557
3558   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3559     {
3560       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3561           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3562         {
3563           /* If newdecl is not a specialization, then it is not a
3564              template-related function at all.  And that means that we
3565              shoud have exited above, returning 0.  */
3566           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3567                               0);
3568
3569           if (TREE_USED (olddecl))
3570             /* From [temp.expl.spec]:
3571
3572                If a template, a member template or the member of a class
3573                template is explicitly specialized then that
3574                specialization shall be declared before the first use of
3575                that specialization that would cause an implicit
3576                instantiation to take place, in every translation unit in
3577                which such a use occurs.  */
3578             cp_error ("explicit specialization of %D after first use",
3579                       olddecl);
3580
3581           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3582         }
3583       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3584
3585       /* If either decl says `inline', this fn is inline, unless its
3586          definition was passed already.  */
3587       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3588         DECL_INLINE (olddecl) = 1;
3589       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3590
3591       if (! types_match)
3592         {
3593           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3594           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3595           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3596         }
3597       if (! types_match || new_defines_function)
3598         {
3599           /* These need to be copied so that the names are available.
3600              Note that if the types do match, we'll preserve inline
3601              info and other bits, but if not, we won't.  */
3602           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3603           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3604         }
3605       if (new_defines_function)
3606         /* If defining a function declared with other language
3607            linkage, use the previously declared language linkage.  */
3608         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3609       else if (types_match)
3610         {
3611           /* If redeclaring a builtin function, and not a definition,
3612              it stays built in.  */
3613           if (DECL_BUILT_IN (olddecl))
3614             {
3615               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3616               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3617               /* If we're keeping the built-in definition, keep the rtl,
3618                  regardless of declaration matches.  */
3619               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3620             }
3621           else
3622             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3623
3624           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3625           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3626             /* Previously saved insns go together with
3627                the function's previous definition.  */
3628             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3629           /* Don't clear out the arguments if we're redefining a function.  */
3630           if (DECL_ARGUMENTS (olddecl))
3631             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3632         }
3633     }
3634
3635   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3636     {
3637       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3638     }
3639
3640   /* Now preserve various other info from the definition.  */
3641   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3642   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3643   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3644   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3645
3646   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3647     {
3648       int function_size;
3649
3650       function_size = sizeof (struct tree_decl);
3651
3652       bcopy ((char *) newdecl + sizeof (struct tree_common),
3653              (char *) olddecl + sizeof (struct tree_common),
3654              function_size - sizeof (struct tree_common));
3655
3656       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3657         {
3658           /* If newdecl is a template instantiation, it is possible that
3659              the following sequence of events has occurred:
3660
3661              o A friend function was declared in a class template.  The
3662              class template was instantiated.
3663
3664              o The instantiation of the friend declaration was
3665              recorded on the instantiation list, and is newdecl.
3666
3667              o Later, however, instantiate_class_template called pushdecl
3668              on the newdecl to perform name injection.  But, pushdecl in
3669              turn called duplicate_decls when it discovered that another
3670              declaration of a global function with the same name already
3671              existed.
3672
3673              o Here, in duplicate_decls, we decided to clobber newdecl.
3674
3675              If we're going to do that, we'd better make sure that
3676              olddecl, and not newdecl, is on the list of
3677              instantiations so that if we try to do the instantiation
3678              again we won't get the clobbered declaration.  */
3679
3680           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3681           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3682
3683           for (; decls; decls = TREE_CHAIN (decls))
3684             if (TREE_VALUE (decls) == newdecl)
3685               TREE_VALUE (decls) = olddecl;
3686         }
3687     }
3688   else
3689     {
3690       bcopy ((char *) newdecl + sizeof (struct tree_common),
3691              (char *) olddecl + sizeof (struct tree_common),
3692              sizeof (struct tree_decl) - sizeof (struct tree_common)
3693              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3694     }
3695
3696   DECL_UID (olddecl) = olddecl_uid;
3697   if (olddecl_friend)
3698     DECL_FRIEND_P (olddecl) = 1;
3699
3700   /* NEWDECL contains the merged attribute lists.
3701      Update OLDDECL to be the same.  */
3702   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3703
3704   return 1;
3705 }
3706
3707 /* Record a decl-node X as belonging to the current lexical scope.
3708    Check for errors (such as an incompatible declaration for the same
3709    name already seen in the same scope).
3710
3711    Returns either X or an old decl for the same name.
3712    If an old decl is returned, it may have been smashed
3713    to agree with what X says.  */
3714
3715 tree
3716 pushdecl (x)
3717      tree x;
3718 {
3719   register tree t;
3720   register tree name;
3721   int need_new_binding;
3722
3723   /* We shouldn't be calling pushdecl when we're generating RTL for a
3724      function that we already did semantic analysis on previously.  */
3725   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3726                       19990913);
3727
3728   name = DECL_ASSEMBLER_NAME (x);
3729   need_new_binding = 1;
3730
3731   if (DECL_TEMPLATE_PARM_P (x))
3732     /* Template parameters have no context; they are not X::T even
3733        when declared within a class or namespace.  */
3734     ;
3735   else
3736     {
3737       if (current_function_decl && x != current_function_decl
3738           /* A local declaration for a function doesn't constitute
3739              nesting.  */
3740           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3741           /* A local declaration for an `extern' variable is in the
3742              scoped of the current namespace, not the current
3743              function.  */
3744           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3745           && !DECL_CONTEXT (x))
3746         DECL_CONTEXT (x) = current_function_decl;
3747       if (!DECL_CONTEXT (x))
3748         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3749
3750       /* If this is the declaration for a namespace-scope function,
3751          but the declaration itself is in a local scope, mark the
3752          declaration.  */
3753       if (TREE_CODE (x) == FUNCTION_DECL
3754           && DECL_NAMESPACE_SCOPE_P (x)
3755           && current_function_decl
3756           && x != current_function_decl)
3757         DECL_LOCAL_FUNCTION_P (x) = 1;
3758     }
3759
3760   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3761      compiler wants to use.  */
3762   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3763       || TREE_CODE (x) == NAMESPACE_DECL)
3764     name = DECL_NAME (x);
3765
3766   if (name)
3767     {
3768 #if 0
3769       /* Not needed...see below.  */
3770       char *file;
3771       int line;
3772 #endif
3773       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3774         name = TREE_OPERAND (name, 0);
3775
3776       /* Namespace-scoped variables are not found in the current level. */
3777       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3778         t = namespace_binding (name, DECL_CONTEXT (x));
3779       else
3780         t = lookup_name_current_level (name);
3781       if (t == error_mark_node)
3782         {
3783           /* error_mark_node is 0 for a while during initialization!  */
3784           t = NULL_TREE;
3785           cp_error_at ("`%#D' used prior to declaration", x);
3786         }
3787
3788       else if (t != NULL_TREE)
3789         {
3790 #if 0
3791           /* This is turned off until I have time to do it right (bpk).  */
3792           /* With the code below that uses it...  */
3793           file = DECL_SOURCE_FILE (t);
3794           line = DECL_SOURCE_LINE (t);
3795 #endif
3796           if (TREE_CODE (t) == PARM_DECL)
3797             {
3798               if (DECL_CONTEXT (t) == NULL_TREE)
3799                 fatal ("parse errors have confused me too much");
3800
3801               /* Check for duplicate params.  */
3802               if (duplicate_decls (x, t))
3803                 return t;
3804             }
3805           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3806                     || DECL_FUNCTION_TEMPLATE_P (x))
3807                    && is_overloaded_fn (t))
3808             /* Don't do anything just yet. */;
3809           else if (t == wchar_decl_node)
3810             {
3811               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3812                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3813
3814               /* Throw away the redeclaration.  */
3815               return t;
3816             }
3817           else if (TREE_CODE (t) != TREE_CODE (x))
3818             {
3819               if (duplicate_decls (x, t))
3820                 return t;
3821             }
3822           else if (duplicate_decls (x, t))
3823             {
3824 #if 0
3825               /* This is turned off until I have time to do it right (bpk).  */
3826
3827               /* Also warn if they did a prototype with `static' on it, but
3828                  then later left the `static' off.  */
3829               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3830                 {
3831                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3832                     return t;
3833
3834                   if (extra_warnings)
3835                     {
3836                       cp_warning ("`static' missing from declaration of `%D'",
3837                                   t);
3838                       warning_with_file_and_line (file, line,
3839                                                   "previous declaration of `%s'",
3840                                                   decl_as_string (t, 0));
3841                     }
3842
3843                   /* Now fix things so it'll do what they expect.  */
3844                   if (current_function_decl)
3845                     TREE_PUBLIC (current_function_decl) = 0;
3846                 }
3847               /* Due to interference in memory reclamation (X may be
3848                  obstack-deallocated at this point), we must guard against
3849                  one really special case.  [jason: This should be handled
3850                  by start_function]  */
3851               if (current_function_decl == x)
3852                 current_function_decl = t;
3853 #endif
3854               if (TREE_CODE (t) == TYPE_DECL)
3855                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3856               else if (TREE_CODE (t) == FUNCTION_DECL)
3857                 check_default_args (t);
3858
3859               return t;
3860             }
3861           else if (DECL_MAIN_P (x))
3862             {
3863               /* A redeclaration of main, but not a duplicate of the
3864                  previous one.
3865
3866                  [basic.start.main]
3867
3868                  This function shall not be overloaded.  */
3869               cp_error_at ("invalid redeclaration of `%D'", t);
3870               cp_error ("as `%D'", x);
3871               /* We don't try to push this declaration since that
3872                  causes a crash.  */
3873               return x;
3874             }
3875         }
3876
3877       check_template_shadow (x);
3878
3879       /* If this is a function conjured up by the backend, massage it
3880          so it looks friendly.  */
3881       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3882         {
3883           retrofit_lang_decl (x);
3884           DECL_LANGUAGE (x) = lang_c;
3885         }
3886
3887       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3888         {
3889           t = push_overloaded_decl (x, PUSH_LOCAL);
3890           if (t != x)
3891             return t;
3892           if (!namespace_bindings_p ())
3893             /* We do not need to create a binding for this name;
3894                push_overloaded_decl will have already done so if
3895                necessary.  */
3896             need_new_binding = 0;
3897         }
3898       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3899         {
3900           t = push_overloaded_decl (x, PUSH_GLOBAL);
3901           if (t == x)
3902             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3903           return t;
3904         }
3905
3906       /* If declaring a type as a typedef, copy the type (unless we're
3907          at line 0), and install this TYPE_DECL as the new type's typedef
3908          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3909       if (TREE_CODE (x) == TYPE_DECL)
3910         {
3911           tree type = TREE_TYPE (x);
3912           if (DECL_SOURCE_LINE (x) == 0)
3913             {
3914               if (TYPE_NAME (type) == 0)
3915                 TYPE_NAME (type) = x;
3916             }
3917           else if (type != error_mark_node && TYPE_NAME (type) != x
3918                    /* We don't want to copy the type when all we're
3919                       doing is making a TYPE_DECL for the purposes of
3920                       inlining.  */
3921                    && (!TYPE_NAME (type)
3922                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3923             {
3924               DECL_ORIGINAL_TYPE (x) = type;
3925               type = build_type_copy (type);
3926               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3927               TYPE_NAME (type) = x;
3928               TREE_TYPE (x) = type;
3929             }
3930
3931           if (type != error_mark_node
3932               && TYPE_NAME (type)
3933               && TYPE_IDENTIFIER (type))
3934             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3935                                                   current_binding_level);
3936
3937         }
3938
3939       /* Multiple external decls of the same identifier ought to match.
3940
3941          We get warnings about inline functions where they are defined.
3942          We get warnings about other functions from push_overloaded_decl.
3943
3944          Avoid duplicate warnings where they are used.  */
3945       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3946         {
3947           tree decl;
3948
3949           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3950               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3951                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3952             decl = IDENTIFIER_NAMESPACE_VALUE (name);
3953           else
3954             decl = NULL_TREE;
3955
3956           if (decl
3957               /* If different sort of thing, we already gave an error.  */
3958               && TREE_CODE (decl) == TREE_CODE (x)
3959               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3960             {
3961               cp_pedwarn ("type mismatch with previous external decl", x);
3962               cp_pedwarn_at ("previous external decl of `%#D'", decl);
3963             }
3964         }
3965
3966       /* This name is new in its binding level.
3967          Install the new declaration and return it.  */
3968       if (namespace_bindings_p ())
3969         {
3970           /* Install a global value.  */
3971
3972           /* If the first global decl has external linkage,
3973              warn if we later see static one.  */
3974           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3975             TREE_PUBLIC (name) = 1;
3976
3977           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3978                 && t != NULL_TREE)
3979               /* For an ordinary function, we create a binding from
3980                  the mangled name (i.e., NAME) to the DECL.  But, for
3981                  an `extern "C"' function, the mangled name and the
3982                  ordinary name are the same so we need not do this.  */
3983               && !DECL_EXTERN_C_FUNCTION_P (x))
3984             {
3985               if (TREE_CODE (x) == FUNCTION_DECL)
3986                 my_friendly_assert
3987                   ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
3988                   || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
3989               SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3990             }
3991
3992           /* Don't forget if the function was used via an implicit decl.  */
3993           if (IDENTIFIER_IMPLICIT_DECL (name)
3994               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3995             TREE_USED (x) = 1;
3996
3997           /* Don't forget if its address was taken in that way.  */
3998           if (IDENTIFIER_IMPLICIT_DECL (name)
3999               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4000             TREE_ADDRESSABLE (x) = 1;
4001
4002           /* Warn about mismatches against previous implicit decl.  */
4003           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4004               /* If this real decl matches the implicit, don't complain.  */
4005               && ! (TREE_CODE (x) == FUNCTION_DECL
4006                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4007             cp_warning
4008               ("`%D' was previously implicitly declared to return `int'", x);
4009
4010           /* If new decl is `static' and an `extern' was seen previously,
4011              warn about it.  */
4012           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4013             warn_extern_redeclared_static (x, t);
4014         }
4015       else
4016         {
4017           /* Here to install a non-global value.  */
4018           tree oldlocal = IDENTIFIER_VALUE (name);
4019           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4020
4021           if (need_new_binding)
4022             {
4023               push_local_binding (name, x, 0);
4024               /* Because push_local_binding will hook X on to the
4025                  current_binding_level's name list, we don't want to
4026                  do that again below.  */
4027               need_new_binding = 0;
4028             }
4029
4030           /* If this is a TYPE_DECL, push it into the type value slot.  */
4031           if (TREE_CODE (x) == TYPE_DECL)
4032             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4033                                                   current_binding_level);
4034
4035           /* Clear out any TYPE_DECL shadowed by a namespace so that
4036              we won't think this is a type.  The C struct hack doesn't
4037              go through namespaces.  */
4038           if (TREE_CODE (x) == NAMESPACE_DECL)
4039             set_identifier_type_value_with_scope (name, NULL_TREE,
4040                                                   current_binding_level);
4041
4042           if (oldlocal)
4043             {
4044               tree d = oldlocal;
4045
4046               while (oldlocal
4047                      && TREE_CODE (oldlocal) == VAR_DECL
4048                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4049                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4050
4051               if (oldlocal == NULL_TREE)
4052                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4053             }
4054
4055           /* If this is an extern function declaration, see if we
4056              have a global definition or declaration for the function.  */
4057           if (oldlocal == NULL_TREE
4058               && DECL_EXTERNAL (x)
4059               && oldglobal != NULL_TREE
4060               && TREE_CODE (x) == FUNCTION_DECL
4061               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4062             {
4063               /* We have one.  Their types must agree.  */
4064               if (decls_match (x, oldglobal))
4065                 /* OK */;
4066               else
4067                 {
4068                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4069                   cp_warning_at ("global declaration `%#D'", oldglobal);
4070                 }
4071             }
4072           /* If we have a local external declaration,
4073              and no file-scope declaration has yet been seen,
4074              then if we later have a file-scope decl it must not be static.  */
4075           if (oldlocal == NULL_TREE
4076               && oldglobal == NULL_TREE
4077               && DECL_EXTERNAL (x)
4078               && TREE_PUBLIC (x))
4079             TREE_PUBLIC (name) = 1;
4080
4081           /* Warn if shadowing an argument at the top level of the body.  */
4082           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4083               /* Inline decls shadow nothing.  */
4084               && !DECL_FROM_INLINE (x)
4085               && TREE_CODE (oldlocal) == PARM_DECL
4086               /* Don't complain if it's from an enclosing function.  */
4087               && DECL_CONTEXT (oldlocal) == current_function_decl
4088               && TREE_CODE (x) != PARM_DECL)
4089             {
4090               /* Go to where the parms should be and see if we
4091                  find them there.  */
4092               struct binding_level *b = current_binding_level->level_chain;
4093
4094               if (cleanup_label)
4095                 b = b->level_chain;
4096
4097               /* ARM $8.3 */
4098               if (b->parm_flag == 1)
4099                 cp_error ("declaration of `%#D' shadows a parameter", name);
4100             }
4101
4102           /* Maybe warn if shadowing something else.  */
4103           if (warn_shadow && !DECL_EXTERNAL (x)
4104               /* Inline decls shadow nothing.  */
4105               && !DECL_FROM_INLINE (x)
4106               /* No shadow warnings for internally generated vars.  */
4107               && ! DECL_ARTIFICIAL (x)
4108               /* No shadow warnings for vars made for inlining.  */
4109               && ! DECL_FROM_INLINE (x))
4110             {
4111               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4112                 warning ("declaration of `%s' shadows a parameter",
4113                         IDENTIFIER_POINTER (name));
4114               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4115                        && current_class_ptr
4116                        && !TREE_STATIC (name))
4117                 warning ("declaration of `%s' shadows a member of `this'",
4118                         IDENTIFIER_POINTER (name));
4119               else if (oldlocal != NULL_TREE)
4120                 warning ("declaration of `%s' shadows previous local",
4121                         IDENTIFIER_POINTER (name));
4122               else if (oldglobal != NULL_TREE)
4123                 /* XXX shadow warnings in outer-more namespaces */
4124                 warning ("declaration of `%s' shadows global declaration",
4125                         IDENTIFIER_POINTER (name));
4126             }
4127         }
4128
4129       if (TREE_CODE (x) == FUNCTION_DECL)
4130         check_default_args (x);
4131
4132       /* Keep count of variables in this level with incomplete type.  */
4133       if (TREE_CODE (x) == VAR_DECL
4134           && TREE_TYPE (x) != error_mark_node
4135           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4136                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4137               /* RTTI TD entries are created while defining the type_info.  */
4138               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4139                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4140         {
4141           if (namespace_bindings_p ())
4142             namespace_scope_incomplete
4143               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4144           else
4145             current_binding_level->incomplete
4146               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4147         }
4148     }
4149
4150   if (need_new_binding)
4151     add_decl_to_level (x,
4152                        DECL_NAMESPACE_SCOPE_P (x)
4153                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4154                        : current_binding_level);
4155
4156   return x;
4157 }
4158
4159 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4160    caller to set DECL_CONTEXT properly.  */
4161
4162 static tree
4163 pushdecl_with_scope (x, level)
4164      tree x;
4165      struct binding_level *level;
4166 {
4167   register struct binding_level *b;
4168   tree function_decl = current_function_decl;
4169
4170   current_function_decl = NULL_TREE;
4171   if (level->parm_flag == 2)
4172     {
4173       b = class_binding_level;
4174       class_binding_level = level;
4175       pushdecl_class_level (x);
4176       class_binding_level = b;
4177     }
4178   else
4179     {
4180       b = current_binding_level;
4181       current_binding_level = level;
4182       x = pushdecl (x);
4183       current_binding_level = b;
4184     }
4185   current_function_decl = function_decl;
4186   return x;
4187 }
4188
4189 /* Like pushdecl, only it places X in the current namespace,
4190    if appropriate.  */
4191
4192 tree
4193 pushdecl_namespace_level (x)
4194      tree x;
4195 {
4196   register struct binding_level *b = current_binding_level;
4197   register tree t;
4198
4199   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4200
4201   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4202      what we want.  */
4203   if (TREE_CODE (x) == TYPE_DECL)
4204     {
4205       tree name = DECL_NAME (x);
4206       tree newval;
4207       tree *ptr = (tree *)0;
4208       for (; b != global_binding_level; b = b->level_chain)
4209         {
4210           tree shadowed = b->type_shadowed;
4211           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4212             if (TREE_PURPOSE (shadowed) == name)
4213               {
4214                 ptr = &TREE_VALUE (shadowed);
4215                 /* Can't break out of the loop here because sometimes
4216                    a binding level will have duplicate bindings for
4217                    PT names.  It's gross, but I haven't time to fix it.  */
4218               }
4219         }
4220       newval = TREE_TYPE (x);
4221       if (ptr == (tree *)0)
4222         {
4223           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4224              up here if this is changed to an assertion.  --KR  */
4225           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4226         }
4227       else
4228         {
4229           *ptr = newval;
4230         }
4231     }
4232   return t;
4233 }
4234
4235 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4236    if appropriate.  */
4237
4238 tree
4239 pushdecl_top_level (x)
4240      tree x;
4241 {
4242   push_to_top_level ();
4243   x = pushdecl_namespace_level (x);
4244   pop_from_top_level ();
4245   return x;
4246 }
4247
4248 /* Make the declaration of X appear in CLASS scope.  */
4249
4250 void
4251 pushdecl_class_level (x)
4252      tree x;
4253 {
4254   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4255      scope looks for the pre-mangled name.  */
4256   register tree name;
4257
4258   if (TREE_CODE (x) == OVERLOAD)
4259     x = OVL_CURRENT (x);
4260   name = DECL_NAME (x);
4261
4262   if (name)
4263     {
4264       push_class_level_binding (name, x);
4265       if (TREE_CODE (x) == TYPE_DECL)
4266         set_identifier_type_value (name, TREE_TYPE (x));
4267     }
4268   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4269     {
4270       tree f;
4271
4272       for (f = TYPE_FIELDS (TREE_TYPE (x));
4273            f;
4274            f = TREE_CHAIN (f))
4275         pushdecl_class_level (f);
4276     }
4277 }
4278
4279 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4280    DECL, or a modified version thereof.  */
4281
4282 tree
4283 maybe_push_decl (decl)
4284      tree decl;
4285 {
4286   tree type = TREE_TYPE (decl);
4287
4288   /* Add this decl to the current binding level, but not if it comes
4289      from another scope, e.g. a static member variable.  TEM may equal
4290      DECL or it may be a previous decl of the same name.  */
4291   if (decl == error_mark_node
4292       || (TREE_CODE (decl) != PARM_DECL
4293           && DECL_CONTEXT (decl) != NULL_TREE
4294           /* Definitions of namespace members outside their namespace are
4295              possible. */
4296           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4297       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4298       || TREE_CODE (type) == UNKNOWN_TYPE
4299       /* The declaration of a template specialization does not affect
4300          the functions available for overload resolution, so we do not
4301          call pushdecl.  */
4302       || (TREE_CODE (decl) == FUNCTION_DECL
4303           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4304     return decl;
4305   else
4306     return pushdecl (decl);
4307 }
4308
4309 /* Make the declaration(s) of X appear in CLASS scope
4310    under the name NAME.  */
4311
4312 void
4313 push_class_level_binding (name, x)
4314      tree name;
4315      tree x;
4316 {
4317   tree binding;
4318   /* The class_binding_level will be NULL if x is a template
4319      parameter name in a member template.  */
4320   if (!class_binding_level)
4321     return;
4322
4323   /* Make sure that this new member does not have the same name
4324      as a template parameter.  */
4325   if (TYPE_BEING_DEFINED (current_class_type))
4326     check_template_shadow (x);
4327
4328   /* If this declaration shadows a declaration from an enclosing
4329      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4330      we leave this class.  Record the shadowed declaration here.  */
4331   binding = IDENTIFIER_BINDING (name);
4332   if (binding
4333       && ((TREE_CODE (x) == OVERLOAD
4334            && BINDING_VALUE (binding)
4335            && is_overloaded_fn (BINDING_VALUE (binding)))
4336           || INHERITED_VALUE_BINDING_P (binding)))
4337     {
4338       tree shadow;
4339       tree old_decl;
4340
4341       /* If the old binding was from a base class, and was for a tag
4342          name, slide it over to make room for the new binding.  The
4343          old binding is still visible if explicitly qualified with a
4344          class-key.  */
4345       if (INHERITED_VALUE_BINDING_P (binding)
4346           && BINDING_VALUE (binding)
4347           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4348           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4349           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4350         {
4351           old_decl = BINDING_TYPE (binding);
4352           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4353           BINDING_VALUE (binding) = NULL_TREE;
4354           INHERITED_VALUE_BINDING_P (binding) = 0;
4355         }
4356       else
4357         old_decl = BINDING_VALUE (binding);
4358
4359       /* There was already a binding for X containing fewer
4360          functions than are named in X.  Find the previous
4361          declaration of X on the class-shadowed list, and update it.  */
4362       for (shadow = class_binding_level->class_shadowed;
4363            shadow;
4364            shadow = TREE_CHAIN (shadow))
4365         if (TREE_PURPOSE (shadow) == name
4366             && TREE_TYPE (shadow) == old_decl)
4367           {
4368             BINDING_VALUE (binding) = x;
4369             INHERITED_VALUE_BINDING_P (binding) = 0;
4370             TREE_TYPE (shadow) = x;
4371             return;
4372           }
4373     }
4374
4375   /* If we didn't replace an existing binding, put the binding on the
4376      stack of bindings for the identifier, and update
4377      IDENTIFIER_CLASS_VALUE.  */
4378   if (push_class_binding (name, x))
4379     {
4380       class_binding_level->class_shadowed
4381         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4382                      class_binding_level->class_shadowed);
4383       /* Record the value we are binding NAME to so that we can know
4384          what to pop later.  */
4385       TREE_TYPE (class_binding_level->class_shadowed) = x;
4386     }
4387 }
4388
4389 /* Insert another USING_DECL into the current binding level, returning
4390    this declaration. If this is a redeclaration, do nothing, and
4391    return NULL_TREE if this not in namespace scope (in namespace
4392    scope, a using decl might extend any previous bindings).  */
4393
4394 tree
4395 push_using_decl (scope, name)
4396      tree scope;
4397      tree name;
4398 {
4399   tree decl;
4400
4401   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4402   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4403   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4404     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4405       break;
4406   if (decl)
4407     return namespace_bindings_p () ? decl : NULL_TREE;
4408   decl = build_lang_decl (USING_DECL, name, void_type_node);
4409   DECL_INITIAL (decl) = scope;
4410   TREE_CHAIN (decl) = current_binding_level->usings;
4411   current_binding_level->usings = decl;
4412   return decl;
4413 }
4414
4415 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4416    changed (i.e. there was already a directive), or the fresh
4417    TREE_LIST otherwise.  */
4418
4419 tree
4420 push_using_directive (used)
4421      tree used;
4422 {
4423   tree ud = current_binding_level->using_directives;
4424   tree iter, ancestor;
4425
4426   /* Check if we already have this. */
4427   if (purpose_member (used, ud) != NULL_TREE)
4428     return NULL_TREE;
4429
4430   /* Recursively add all namespaces used. */
4431   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4432     push_using_directive (TREE_PURPOSE (iter));
4433
4434   ancestor = namespace_ancestor (current_decl_namespace (), used);
4435   ud = current_binding_level->using_directives;
4436   ud = tree_cons (used, ancestor, ud);
4437   current_binding_level->using_directives = ud;
4438   return ud;
4439 }
4440
4441 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4442    other definitions already in place.  We get around this by making
4443    the value of the identifier point to a list of all the things that
4444    want to be referenced by that name.  It is then up to the users of
4445    that name to decide what to do with that list.
4446
4447    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4448    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4449
4450    FLAGS is a bitwise-or of the following values:
4451      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4452                  namespace scope.
4453      PUSH_USING: DECL is being pushed as the result of a using
4454                  declaration.
4455
4456    The value returned may be a previous declaration if we guessed wrong
4457    about what language DECL should belong to (C or C++).  Otherwise,
4458    it's always DECL (and never something that's not a _DECL).  */
4459
4460 tree
4461 push_overloaded_decl (decl, flags)
4462      tree decl;
4463      int flags;
4464 {
4465   tree name = DECL_NAME (decl);
4466   tree old;
4467   tree new_binding;
4468   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4469
4470   if (doing_global)
4471     old = namespace_binding (name, DECL_CONTEXT (decl));
4472   else
4473     old = lookup_name_current_level (name);
4474
4475   if (old)
4476     {
4477       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4478         {
4479           tree t = TREE_TYPE (old);
4480           if (IS_AGGR_TYPE (t) && warn_shadow
4481               && (! DECL_IN_SYSTEM_HEADER (decl)
4482                   || ! DECL_IN_SYSTEM_HEADER (old)))
4483             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4484           old = NULL_TREE;
4485         }
4486       else if (is_overloaded_fn (old))
4487         {
4488           tree tmp;
4489
4490           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4491             {
4492               tree fn = OVL_CURRENT (tmp);
4493
4494               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4495                   && !(flags & PUSH_USING)
4496                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4497                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4498                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4499                           decl, fn);
4500
4501               if (duplicate_decls (decl, fn))
4502                 return fn;
4503             }
4504         }
4505       else
4506         {
4507           cp_error_at ("previous non-function declaration `%#D'", old);
4508           cp_error ("conflicts with function declaration `%#D'", decl);
4509           return decl;
4510         }
4511     }
4512
4513   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4514     {
4515       if (old && TREE_CODE (old) != OVERLOAD)
4516         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4517       else
4518         new_binding = ovl_cons (decl, old);
4519       if (flags & PUSH_USING)
4520         OVL_USED (new_binding) = 1;
4521     }
4522   else
4523     /* NAME is not ambiguous.  */
4524     new_binding = decl;
4525
4526   if (doing_global)
4527     set_namespace_binding (name, current_namespace, new_binding);
4528   else
4529     {
4530       /* We only create an OVERLOAD if there was a previous binding at
4531          this level, or if decl is a template. In the former case, we
4532          need to remove the old binding and replace it with the new
4533          binding.  We must also run through the NAMES on the binding
4534          level where the name was bound to update the chain.  */
4535
4536       if (TREE_CODE (new_binding) == OVERLOAD && old)
4537         {
4538           tree *d;
4539
4540           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4541                *d;
4542                d = &TREE_CHAIN (*d))
4543             if (*d == old
4544                 || (TREE_CODE (*d) == TREE_LIST
4545                     && TREE_VALUE (*d) == old))
4546               {
4547                 if (TREE_CODE (*d) == TREE_LIST)
4548                   /* Just replace the old binding with the new.  */
4549                   TREE_VALUE (*d) = new_binding;
4550                 else
4551                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4552                   *d = tree_cons (NULL_TREE, new_binding,
4553                                   TREE_CHAIN (*d));
4554
4555                 /* And update the CPLUS_BINDING node.  */
4556                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4557                   = new_binding;
4558                 return decl;
4559               }
4560
4561           /* We should always find a previous binding in this case.  */
4562           my_friendly_abort (0);
4563         }
4564
4565       /* Install the new binding.  */
4566       push_local_binding (name, new_binding, flags);
4567     }
4568
4569   return decl;
4570 }
4571 \f
4572 /* Generate an implicit declaration for identifier FUNCTIONID
4573    as a function of type int ().  Print a warning if appropriate.  */
4574
4575 tree
4576 implicitly_declare (functionid)
4577      tree functionid;
4578 {
4579   register tree decl;
4580
4581   /* We used to reuse an old implicit decl here,
4582      but this loses with inline functions because it can clobber
4583      the saved decl chains.  */
4584   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4585
4586   DECL_EXTERNAL (decl) = 1;
4587   TREE_PUBLIC (decl) = 1;
4588
4589   /* ISO standard says implicit declarations are in the innermost block.
4590      So we record the decl in the standard fashion.  */
4591   pushdecl (decl);
4592   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4593
4594   if (warn_implicit
4595       /* Only one warning per identifier.  */
4596       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4597     {
4598       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4599     }
4600
4601   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4602
4603   return decl;
4604 }
4605
4606 /* Return zero if the declaration NEWDECL is valid
4607    when the declaration OLDDECL (assumed to be for the same name)
4608    has already been seen.
4609    Otherwise return an error message format string with a %s
4610    where the identifier should go.  */
4611
4612 static const char *
4613 redeclaration_error_message (newdecl, olddecl)
4614      tree newdecl, olddecl;
4615 {
4616   if (TREE_CODE (newdecl) == TYPE_DECL)
4617     {
4618       /* Because C++ can put things into name space for free,
4619          constructs like "typedef struct foo { ... } foo"
4620          would look like an erroneous redeclaration.  */
4621       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4622         return 0;
4623       else
4624         return "redefinition of `%#D'";
4625     }
4626   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4627     {
4628       /* If this is a pure function, its olddecl will actually be
4629          the original initialization to `0' (which we force to call
4630          abort()).  Don't complain about redefinition in this case.  */
4631       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4632         return 0;
4633
4634       /* If both functions come from different namespaces, this is not
4635          a redeclaration - this is a conflict with a used function. */
4636       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4637           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4638         return "`%D' conflicts with used function";
4639
4640       /* We'll complain about linkage mismatches in
4641          warn_extern_redeclared_static.  */
4642
4643       /* Defining the same name twice is no good.  */
4644       if (DECL_INITIAL (olddecl) != NULL_TREE
4645           && DECL_INITIAL (newdecl) != NULL_TREE)
4646         {
4647           if (DECL_NAME (olddecl) == NULL_TREE)
4648             return "`%#D' not declared in class";
4649           else
4650             return "redefinition of `%#D'";
4651         }
4652       return 0;
4653     }
4654   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4655     {
4656       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4657            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4658            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4659           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4660               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4661               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4662         return "redefinition of `%#D'";
4663       return 0;
4664     }
4665   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4666     {
4667       /* Objects declared at top level:  */
4668       /* If at least one is a reference, it's ok.  */
4669       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4670         return 0;
4671       /* Reject two definitions.  */
4672       return "redefinition of `%#D'";
4673     }
4674   else
4675     {
4676       /* Objects declared with block scope:  */
4677       /* Reject two definitions, and reject a definition
4678          together with an external reference.  */
4679       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4680         return "redeclaration of `%#D'";
4681       return 0;
4682     }
4683 }
4684 \f
4685 /* Create a new label, named ID.  */
4686
4687 static tree
4688 make_label_decl (id, local_p)
4689      tree id;
4690      int local_p;
4691 {
4692   tree decl;
4693
4694   decl = build_decl (LABEL_DECL, id, void_type_node);
4695   if (expanding_p)
4696     /* Make sure every label has an rtx.  */
4697     label_rtx (decl);
4698
4699   DECL_CONTEXT (decl) = current_function_decl;
4700   DECL_MODE (decl) = VOIDmode;
4701   C_DECLARED_LABEL_FLAG (decl) = local_p;
4702
4703   /* Say where one reference is to the label, for the sake of the
4704      error if it is not defined.  */
4705   DECL_SOURCE_LINE (decl) = lineno;
4706   DECL_SOURCE_FILE (decl) = input_filename;
4707
4708   /* Record the fact that this identifier is bound to this label.  */
4709   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4710
4711   /* Record this label on the list of used labels so that we can check
4712      at the end of the function to see whether or not the label was
4713      actually defined.  */
4714   if ((named_label_uses == NULL || named_label_uses->label_decl != decl)
4715       && (named_label_uses == NULL
4716           || named_label_uses->names_in_scope != current_binding_level->names
4717           || named_label_uses->label_decl != decl))
4718     {
4719       struct named_label_list *new_ent;
4720       new_ent
4721         = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4722       new_ent->label_decl = decl;
4723       new_ent->names_in_scope = current_binding_level->names;
4724       new_ent->binding_level = current_binding_level;
4725       new_ent->lineno_o_goto = lineno;
4726       new_ent->filename_o_goto = input_filename;
4727       new_ent->next = named_label_uses;
4728       named_label_uses = new_ent;
4729     }
4730
4731   return decl;
4732 }
4733
4734 /* Look for a label named ID in the current function.  If one cannot
4735    be found, create one.  (We keep track of used, but undefined,
4736    labels, and complain about them at the end of a function.)  */
4737
4738 tree
4739 lookup_label (id)
4740      tree id;
4741 {
4742   tree decl;
4743
4744   /* You can't use labels at global scope.  */
4745   if (current_function_decl == NULL_TREE)
4746     {
4747       error ("label `%s' referenced outside of any function",
4748              IDENTIFIER_POINTER (id));
4749       return NULL_TREE;
4750     }
4751
4752   /* See if we've already got this label.  */
4753   decl = IDENTIFIER_LABEL_VALUE (id);
4754   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4755     return decl;
4756
4757   /* Record this label on the list of labels used in this function.
4758      We do this before calling make_label_decl so that we get the
4759      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4760   named_labels = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4761                             named_labels);
4762   /* We need a new label.  */
4763   decl = make_label_decl (id, /*local_p=*/0);
4764   /* Now fill in the information we didn't have before.  */
4765   TREE_VALUE (named_labels) = decl;
4766
4767   return decl;
4768 }
4769
4770 /* Declare a local label named ID.  */
4771
4772 tree
4773 declare_local_label (id)
4774      tree id;
4775 {
4776   tree decl;
4777
4778   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4779      this scope we can restore the old value of
4780      IDENTIFIER_TYPE_VALUE.  */
4781   current_binding_level->shadowed_labels
4782     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4783                  current_binding_level->shadowed_labels);
4784   /* Look for the label.  */
4785   decl = make_label_decl (id, /*local_p=*/1);
4786   /* Now fill in the information we didn't have before.  */
4787   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4788
4789   return decl;
4790 }
4791
4792 /* Define a label, specifying the location in the source file.
4793    Return the LABEL_DECL node for the label, if the definition is valid.
4794    Otherwise return 0.  */
4795
4796 tree
4797 define_label (filename, line, name)
4798      const char *filename;
4799      int line;
4800      tree name;
4801 {
4802   tree decl = lookup_label (name);
4803
4804   /* After labels, make any new cleanups go into their
4805      own new (temporary) binding contour.  */
4806   current_binding_level->more_cleanups_ok = 0;
4807
4808   if (name == get_identifier ("wchar_t"))
4809     cp_pedwarn ("label named wchar_t");
4810
4811   if (DECL_INITIAL (decl) != NULL_TREE)
4812     {
4813       cp_error ("duplicate label `%D'", decl);
4814       return 0;
4815     }
4816   else
4817     {
4818       struct named_label_list *uses, *prev;
4819       int identified = 0;
4820       int saw_eh = 0;
4821
4822       /* Mark label as having been defined.  */
4823       DECL_INITIAL (decl) = error_mark_node;
4824       /* Say where in the source.  */
4825       DECL_SOURCE_FILE (decl) = filename;
4826       DECL_SOURCE_LINE (decl) = line;
4827
4828       prev = NULL;
4829       uses = named_label_uses;
4830       while (uses != NULL)
4831         if (uses->label_decl == decl)
4832           {
4833             struct binding_level *b = current_binding_level;
4834             while (b)
4835               {
4836                 tree new_decls = b->names;
4837                 tree old_decls = (b == uses->binding_level)
4838                                   ? uses->names_in_scope : NULL_TREE;
4839                 while (new_decls != old_decls)
4840                   {
4841                     if (TREE_CODE (new_decls) == VAR_DECL
4842                         /* Don't complain about crossing initialization
4843                            of internal entities.  They can't be accessed,
4844                            and they should be cleaned up
4845                            by the time we get to the label.  */
4846                         && ! DECL_ARTIFICIAL (new_decls)
4847                         && !(DECL_INITIAL (new_decls) == NULL_TREE
4848                              && pod_type_p (TREE_TYPE (new_decls))))
4849                       {
4850                         /* This is really only important if we're crossing
4851                            an initialization.  The POD stuff is just
4852                            pedantry; why should it matter if the class
4853                            contains a field of pointer to member type?  */
4854                         int problem = (DECL_INITIAL (new_decls)
4855                                        || (TYPE_NEEDS_CONSTRUCTING
4856                                            (TREE_TYPE (new_decls))));
4857
4858                         if (! identified)
4859                           {
4860                             if (problem)
4861                               {
4862                                 cp_error ("jump to label `%D'", decl);
4863                                 error_with_file_and_line
4864                                   (uses->filename_o_goto,
4865                                    uses->lineno_o_goto, "  from here");
4866                               }
4867                             else
4868                               {
4869                                 cp_pedwarn ("jump to label `%D'", decl);
4870                                 pedwarn_with_file_and_line
4871                                   (uses->filename_o_goto,
4872                                    uses->lineno_o_goto, "  from here");
4873                               }
4874                             identified = 1;
4875                           }
4876
4877                         if (problem)
4878                           cp_error_at ("  crosses initialization of `%#D'",
4879                                        new_decls);
4880                         else
4881                           cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4882                                          new_decls);
4883                       }
4884                     new_decls = TREE_CHAIN (new_decls);
4885                   }
4886                 if (b == uses->binding_level)
4887                   break;
4888                 if (b->eh_region && ! saw_eh)
4889                   {
4890                     if (! identified)
4891                       {
4892                         cp_error ("jump to label `%D'", decl);
4893                         error_with_file_and_line
4894                           (uses->filename_o_goto,
4895                            uses->lineno_o_goto, "  from here");
4896                         identified = 1;
4897                       }
4898                     error ("  enters exception handling block");
4899                     saw_eh = 1;
4900                   }
4901                 b = b->level_chain;
4902               }
4903
4904             if (prev != NULL)
4905               prev->next = uses->next;
4906             else
4907               named_label_uses = uses->next;
4908
4909             uses = uses->next;
4910           }
4911         else
4912           {
4913             prev = uses;
4914             uses = uses->next;
4915           }
4916       current_function_return_value = NULL_TREE;
4917       return decl;
4918     }
4919 }
4920
4921 struct cp_switch
4922 {
4923   struct binding_level *level;
4924   struct cp_switch *next;
4925 };
4926
4927 static struct cp_switch *switch_stack;
4928
4929 void
4930 push_switch ()
4931 {
4932   struct cp_switch *p
4933     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
4934   p->level = current_binding_level;
4935   p->next = switch_stack;
4936   switch_stack = p;
4937 }
4938
4939 void
4940 pop_switch ()
4941 {
4942   struct cp_switch *cs;
4943
4944   cs = switch_stack;
4945   switch_stack = switch_stack->next;
4946   free (cs);
4947 }
4948
4949 /* Note that we've seen a definition of a case label, and complain if this
4950    is a bad place for one.  */
4951
4952 void
4953 define_case_label ()
4954 {
4955   tree cleanup = last_cleanup_this_contour ();
4956   struct binding_level *b = current_binding_level;
4957   int identified = 0;
4958
4959   if (! switch_stack)
4960     /* Don't crash; we'll complain in do_case.  */
4961     return;
4962
4963   if (cleanup)
4964     {
4965       static int explained = 0;
4966       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4967       warning ("where case label appears here");
4968       if (!explained)
4969         {
4970           warning ("(enclose actions of previous case statements requiring");
4971           warning ("destructors in their own binding contours.)");
4972           explained = 1;
4973         }
4974     }
4975
4976   for (; b && b != switch_stack->level; b = b->level_chain)
4977     {
4978       tree new_decls = b->names;
4979       for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4980         {
4981           if (TREE_CODE (new_decls) == VAR_DECL
4982               /* Don't complain about crossing initialization
4983                  of internal entities.  They can't be accessed,
4984                  and they should be cleaned up
4985                  by the time we get to the label.  */
4986               && ! DECL_ARTIFICIAL (new_decls)
4987               && ((DECL_INITIAL (new_decls) != NULL_TREE
4988                    && DECL_INITIAL (new_decls) != error_mark_node)
4989                   || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4990             {
4991               if (! identified)
4992                 error ("jump to case label");
4993               identified = 1;
4994               cp_error_at ("  crosses initialization of `%#D'",
4995                            new_decls);
4996             }
4997         }
4998     }
4999
5000   /* After labels, make any new cleanups go into their
5001      own new (temporary) binding contour.  */
5002
5003   current_binding_level->more_cleanups_ok = 0;
5004   current_function_return_value = NULL_TREE;
5005 }
5006 \f
5007 /* Return the list of declarations of the current level.
5008    Note that this list is in reverse order unless/until
5009    you nreverse it; and when you do nreverse it, you must
5010    store the result back using `storedecls' or you will lose.  */
5011
5012 tree
5013 getdecls ()
5014 {
5015   return current_binding_level->names;
5016 }
5017
5018 /* Return the list of type-tags (for structs, etc) of the current level.  */
5019
5020 tree
5021 gettags ()
5022 {
5023   return current_binding_level->tags;
5024 }
5025
5026 /* Store the list of declarations of the current level.
5027    This is done for the parameter declarations of a function being defined,
5028    after they are modified in the light of any missing parameters.  */
5029
5030 static void
5031 storedecls (decls)
5032      tree decls;
5033 {
5034   current_binding_level->names = decls;
5035 }
5036
5037 /* Similarly, store the list of tags of the current level.  */
5038
5039 void
5040 storetags (tags)
5041      tree tags;
5042 {
5043   current_binding_level->tags = tags;
5044 }
5045 \f
5046 /* Given NAME, an IDENTIFIER_NODE,
5047    return the structure (or union or enum) definition for that name.
5048    Searches binding levels from BINDING_LEVEL up to the global level.
5049    If THISLEVEL_ONLY is nonzero, searches only the specified context
5050    (but skips any tag-transparent contexts to find one that is
5051    meaningful for tags).
5052    FORM says which kind of type the caller wants;
5053    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5054    If the wrong kind of type is found, and it's not a template, an error is
5055    reported.  */
5056
5057 static tree
5058 lookup_tag (form, name, binding_level, thislevel_only)
5059      enum tree_code form;
5060      tree name;
5061      struct binding_level *binding_level;
5062      int thislevel_only;
5063 {
5064   register struct binding_level *level;
5065   /* Non-zero if, we should look past a template parameter level, even
5066      if THISLEVEL_ONLY.  */
5067   int allow_template_parms_p = 1;
5068
5069   for (level = binding_level; level; level = level->level_chain)
5070     {
5071       register tree tail;
5072       if (ANON_AGGRNAME_P (name))
5073         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5074           {
5075             /* There's no need for error checking here, because
5076                anon names are unique throughout the compilation.  */
5077             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5078               return TREE_VALUE (tail);
5079           }
5080       else if (level->namespace_p)
5081         /* Do namespace lookup. */
5082         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5083           {
5084             tree old = binding_for_name (name, tail);
5085
5086             /* If we just skipped past a template parameter level,
5087                even though THISLEVEL_ONLY, and we find a template
5088                class declaration, then we use the _TYPE node for the
5089                template.  See the example below.  */
5090             if (thislevel_only && !allow_template_parms_p
5091                 && old && BINDING_VALUE (old)
5092                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5093               old = TREE_TYPE (BINDING_VALUE (old));
5094             else
5095               old = BINDING_TYPE (old);
5096
5097             /* If it has an original type, it is a typedef, and we
5098                should not return it.  */
5099             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5100               old = NULL_TREE;
5101             if (old && TREE_CODE (old) != form
5102                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5103               {
5104                 cp_error ("`%#D' redeclared as %C", old, form);
5105                 return NULL_TREE;
5106               }
5107             if (old)
5108               return old;
5109             if (thislevel_only || tail == global_namespace)
5110               return NULL_TREE;
5111           }
5112       else
5113         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5114           {
5115             if (TREE_PURPOSE (tail) == name)
5116               {
5117                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5118                 /* Should tighten this up; it'll probably permit
5119                    UNION_TYPE and a struct template, for example.  */
5120                 if (code != form
5121                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5122                   {
5123                     /* Definition isn't the kind we were looking for.  */
5124                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5125                               form);
5126                     return NULL_TREE;
5127                   }
5128                 return TREE_VALUE (tail);
5129               }
5130           }
5131       if (thislevel_only && ! level->tag_transparent)
5132         {
5133           if (level->template_parms_p && allow_template_parms_p)
5134             {
5135               /* We must deal with cases like this:
5136
5137                    template <class T> struct S;
5138                    template <class T> struct S {};
5139
5140                  When looking up `S', for the second declaration, we
5141                  would like to find the first declaration.  But, we
5142                  are in the pseudo-global level created for the
5143                  template parameters, rather than the (surrounding)
5144                  namespace level.  Thus, we keep going one more level,
5145                  even though THISLEVEL_ONLY is non-zero.  */
5146               allow_template_parms_p = 0;
5147               continue;
5148             }
5149           else
5150             return NULL_TREE;
5151         }
5152     }
5153   return NULL_TREE;
5154 }
5155
5156 #if 0
5157 void
5158 set_current_level_tags_transparency (tags_transparent)
5159      int tags_transparent;
5160 {
5161   current_binding_level->tag_transparent = tags_transparent;
5162 }
5163 #endif
5164
5165 /* Given a type, find the tag that was defined for it and return the tag name.
5166    Otherwise return 0.  However, the value can never be 0
5167    in the cases in which this is used.
5168
5169    C++: If NAME is non-zero, this is the new name to install.  This is
5170    done when replacing anonymous tags with real tag names.  */
5171
5172 static tree
5173 lookup_tag_reverse (type, name)
5174      tree type;
5175      tree name;
5176 {
5177   register struct binding_level *level;
5178
5179   for (level = current_binding_level; level; level = level->level_chain)
5180     {
5181       register tree tail;
5182       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5183         {
5184           if (TREE_VALUE (tail) == type)
5185             {
5186               if (name)
5187                 TREE_PURPOSE (tail) = name;
5188               return TREE_PURPOSE (tail);
5189             }
5190         }
5191     }
5192   return NULL_TREE;
5193 }
5194 \f
5195 /* Look up NAME in the NAMESPACE.  */
5196
5197 tree
5198 lookup_namespace_name (namespace, name)
5199      tree namespace, name;
5200 {
5201   tree val;
5202   tree template_id = NULL_TREE;
5203
5204   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5205
5206   if (TREE_CODE (name) == NAMESPACE_DECL)
5207     /* This happens for A::B<int> when B is a namespace. */
5208     return name;
5209   else if (TREE_CODE (name) == TEMPLATE_DECL)
5210     {
5211       /* This happens for A::B where B is a template, and there are no
5212          template arguments.  */
5213       cp_error ("invalid use of `%D'", name);
5214       return error_mark_node;
5215     }
5216
5217   namespace = ORIGINAL_NAMESPACE (namespace);
5218
5219   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5220     {
5221       template_id = name;
5222       name = TREE_OPERAND (name, 0);
5223       if (TREE_CODE (name) == OVERLOAD)
5224         name = DECL_NAME (OVL_CURRENT (name));
5225       else if (DECL_P (name))
5226         name = DECL_NAME (name);
5227     }
5228
5229   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5230
5231   val = make_node (CPLUS_BINDING);
5232   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5233     return error_mark_node;
5234
5235   if (BINDING_VALUE (val))
5236     {
5237       val = BINDING_VALUE (val);
5238
5239       if (template_id)
5240         {
5241           if (DECL_CLASS_TEMPLATE_P (val))
5242             val = lookup_template_class (val,
5243                                          TREE_OPERAND (template_id, 1),
5244                                          /*in_decl=*/NULL_TREE,
5245                                          /*context=*/NULL_TREE,
5246                                          /*entering_scope=*/0);
5247           else if (DECL_FUNCTION_TEMPLATE_P (val)
5248                    || TREE_CODE (val) == OVERLOAD)
5249             val = lookup_template_function (val,
5250                                             TREE_OPERAND (template_id, 1));
5251           else
5252             {
5253               cp_error ("`%D::%D' is not a template",
5254                         namespace, name);
5255               return error_mark_node;
5256             }
5257         }
5258
5259       /* If we have a single function from a using decl, pull it out.  */
5260       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5261         val = OVL_FUNCTION (val);
5262       return val;
5263     }
5264
5265   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5266   return error_mark_node;
5267 }
5268
5269 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5270
5271 static unsigned long
5272 typename_hash (k)
5273      hash_table_key k;
5274 {
5275   unsigned long hash;
5276   tree t;
5277
5278   t = (tree) k;
5279   hash = (((unsigned long) TYPE_CONTEXT (t))
5280           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5281
5282   return hash;
5283 }
5284
5285 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5286
5287 static boolean
5288 typename_compare (k1, k2)
5289      hash_table_key k1;
5290      hash_table_key k2;
5291 {
5292   tree t1;
5293   tree t2;
5294   tree d1;
5295   tree d2;
5296
5297   t1 = (tree) k1;
5298   t2 = (tree) k2;
5299   d1 = TYPE_NAME (t1);
5300   d2 = TYPE_NAME (t2);
5301
5302   return (DECL_NAME (d1) == DECL_NAME (d2)
5303           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5304           && ((TREE_TYPE (t1) != NULL_TREE)
5305               == (TREE_TYPE (t2) != NULL_TREE))
5306           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5307           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5308 }
5309
5310 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5311    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5312    is non-NULL, this type is being created by the implicit typename
5313    extension, and BASE_TYPE is a type named `t' in some base class of
5314    `T' which depends on template parameters.
5315
5316    Returns the new TYPENAME_TYPE.  */
5317
5318 tree
5319 build_typename_type (context, name, fullname, base_type)
5320      tree context;
5321      tree name;
5322      tree fullname;
5323      tree base_type;
5324 {
5325   tree t;
5326   tree d;
5327   struct hash_entry* e;
5328
5329   static struct hash_table ht;
5330
5331   if (!ht.table)
5332     {
5333       static struct hash_table *h = &ht;
5334       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5335                             &typename_compare))
5336         fatal ("virtual memory exhausted");
5337       ggc_add_tree_hash_table_root (&h, 1);
5338     }
5339
5340   /* Build the TYPENAME_TYPE.  */
5341   t = make_aggr_type (TYPENAME_TYPE);
5342   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5343   TYPENAME_TYPE_FULLNAME (t) = fullname;
5344   TREE_TYPE (t) = base_type;
5345
5346   /* Build the corresponding TYPE_DECL.  */
5347   d = build_decl (TYPE_DECL, name, t);
5348   TYPE_NAME (TREE_TYPE (d)) = d;
5349   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5350   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5351   DECL_ARTIFICIAL (d) = 1;
5352
5353   /* See if we already have this type.  */
5354   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5355   if (e)
5356     t = (tree) e->key;
5357   else
5358     /* Insert the type into the table.  */
5359     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5360
5361   return t;
5362 }
5363
5364 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5365    unless an error occurs, in which case error_mark_node is returned.
5366    If COMPLAIN zero, don't complain about any errors that occur.  */
5367
5368 tree
5369 make_typename_type (context, name, complain)
5370      tree context, name;
5371      int complain;
5372 {
5373   tree fullname;
5374
5375   if (TYPE_P (name))
5376     {
5377       if (!(TYPE_LANG_SPECIFIC (name)
5378             && (CLASSTYPE_IS_TEMPLATE (name)
5379                 || CLASSTYPE_USE_TEMPLATE (name))))
5380         name = TYPE_IDENTIFIER (name);
5381       else
5382         /* Create a TEMPLATE_ID_EXPR for the type.  */
5383         name = build_nt (TEMPLATE_ID_EXPR,
5384                          CLASSTYPE_TI_TEMPLATE (name),
5385                          CLASSTYPE_TI_ARGS (name));
5386     }
5387   else if (TREE_CODE (name) == TYPE_DECL)
5388     name = DECL_NAME (name);
5389
5390   fullname = name;
5391
5392   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5393     {
5394       name = TREE_OPERAND (name, 0);
5395       if (TREE_CODE (name) == TEMPLATE_DECL)
5396         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5397     }
5398   if (TREE_CODE (name) != IDENTIFIER_NODE)
5399     my_friendly_abort (2000);
5400
5401   if (TREE_CODE (context) == NAMESPACE_DECL)
5402     {
5403       /* We can get here from typename_sub0 in the explicit_template_type
5404          expansion.  Just fail.  */
5405       if (complain)
5406         cp_error ("no class template named `%#T' in `%#T'",
5407                   name, context);
5408       return error_mark_node;
5409     }
5410
5411   if (! uses_template_parms (context)
5412       || currently_open_class (context))
5413     {
5414       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5415         {
5416           tree tmpl = NULL_TREE;
5417           if (IS_AGGR_TYPE (context))
5418             tmpl = lookup_field (context, name, 0, 0);
5419           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5420             {
5421               if (complain)
5422                 cp_error ("no class template named `%#T' in `%#T'",
5423                           name, context);
5424               return error_mark_node;
5425             }
5426
5427           return lookup_template_class (tmpl,
5428                                         TREE_OPERAND (fullname, 1),
5429                                         NULL_TREE, context,
5430                                         /*entering_scope=*/0);
5431         }
5432       else
5433         {
5434           tree t;
5435
5436           if (!IS_AGGR_TYPE (context))
5437             {
5438               if (complain)
5439                 cp_error ("no type named `%#T' in `%#T'", name, context);
5440               return error_mark_node;
5441             }
5442
5443           t = lookup_field (context, name, 0, 1);
5444           if (t)
5445             return TREE_TYPE (t);
5446         }
5447     }
5448
5449   /* If the CONTEXT is not a template type, then either the field is
5450      there now or its never going to be.  */
5451   if (!uses_template_parms (context))
5452     {
5453       if (complain)
5454         cp_error ("no type named `%#T' in `%#T'", name, context);
5455       return error_mark_node;
5456     }
5457
5458
5459   return build_typename_type (context, name, fullname,  NULL_TREE);
5460 }
5461
5462 /* Select the right _DECL from multiple choices. */
5463
5464 static tree
5465 select_decl (binding, flags)
5466      tree binding;
5467      int flags;
5468 {
5469   tree val;
5470   val = BINDING_VALUE (binding);
5471   if (LOOKUP_NAMESPACES_ONLY (flags))
5472     {
5473       /* We are not interested in types. */
5474       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5475         return val;
5476       return NULL_TREE;
5477     }
5478
5479   /* If we could have a type and
5480      we have nothing or we need a type and have none.  */
5481   if (BINDING_TYPE (binding)
5482       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5483                    && TREE_CODE (val) != TYPE_DECL)))
5484     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5485   /* Don't return non-types if we really prefer types. */
5486   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5487            && (TREE_CODE (val) != TEMPLATE_DECL
5488                || !DECL_CLASS_TEMPLATE_P (val)))
5489     val = NULL_TREE;
5490
5491   return val;
5492 }
5493
5494 /* Unscoped lookup of a global: iterate over current namespaces,
5495    considering using-directives.  If SPACESP is non-NULL, store a list
5496    of the namespaces we've considered in it.  */
5497
5498 tree
5499 unqualified_namespace_lookup (name, flags, spacesp)
5500      tree name;
5501      int flags;
5502      tree *spacesp;
5503 {
5504   tree b = make_node (CPLUS_BINDING);
5505   tree initial = current_decl_namespace();
5506   tree scope = initial;
5507   tree siter;
5508   struct binding_level *level;
5509   tree val = NULL_TREE;
5510
5511   if (spacesp)
5512     *spacesp = NULL_TREE;
5513
5514   for (; !val; scope = CP_DECL_CONTEXT (scope))
5515     {
5516       if (spacesp)
5517         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5518       val = binding_for_name (name, scope);
5519
5520       /* Initialize binding for this context. */
5521       BINDING_VALUE (b) = BINDING_VALUE (val);
5522       BINDING_TYPE (b) = BINDING_TYPE (val);
5523
5524       /* Add all _DECLs seen through local using-directives. */
5525       for (level = current_binding_level;
5526            !level->namespace_p;
5527            level = level->level_chain)
5528         if (!lookup_using_namespace (name, b, level->using_directives,
5529                                      scope, flags, spacesp))
5530           /* Give up because of error. */
5531           return error_mark_node;
5532
5533       /* Add all _DECLs seen through global using-directives. */
5534       /* XXX local and global using lists should work equally. */
5535       siter = initial;
5536       while (1)
5537         {
5538           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5539                                        scope, flags, spacesp))
5540             /* Give up because of error. */
5541             return error_mark_node;
5542           if (siter == scope) break;
5543           siter = CP_DECL_CONTEXT (siter);
5544         }
5545
5546       val = select_decl (b, flags);
5547       if (scope == global_namespace)
5548         break;
5549     }
5550   return val;
5551 }
5552
5553 /* Combine prefer_type and namespaces_only into flags.  */
5554
5555 static int
5556 lookup_flags (prefer_type, namespaces_only)
5557   int prefer_type, namespaces_only;
5558 {
5559   if (namespaces_only)
5560     return LOOKUP_PREFER_NAMESPACES;
5561   if (prefer_type > 1)
5562     return LOOKUP_PREFER_TYPES;
5563   if (prefer_type > 0)
5564     return LOOKUP_PREFER_BOTH;
5565   return 0;
5566 }
5567
5568 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5569    ignore it or not.  Subroutine of lookup_name_real.  */
5570
5571 static tree
5572 qualify_lookup (val, flags)
5573      tree val;
5574      int flags;
5575 {
5576   if (val == NULL_TREE)
5577     return val;
5578   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5579     return val;
5580   if ((flags & LOOKUP_PREFER_TYPES)
5581       && (TREE_CODE (val) == TYPE_DECL
5582           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5583               && DECL_CLASS_TEMPLATE_P (val))))
5584     return val;
5585   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5586     return NULL_TREE;
5587   return val;
5588 }
5589
5590 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5591    that.  */
5592
5593 static void
5594 warn_about_implicit_typename_lookup (typename, binding)
5595      tree typename;
5596      tree binding;
5597 {
5598   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5599   tree name = DECL_NAME (typename);
5600
5601   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5602          && CLASSTYPE_TEMPLATE_INFO (subtype)
5603          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5604       && ! (TREE_CODE (binding) == TYPE_DECL
5605             && same_type_p (TREE_TYPE (binding), subtype)))
5606     {
5607       cp_warning ("lookup of `%D' finds `%#D'",
5608                   name, binding);
5609       cp_warning ("  instead of `%D' from dependent base class",
5610                   typename);
5611       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5612                   constructor_name (current_class_type), name);
5613     }
5614 }
5615
5616 /* Look up NAME in the current binding level and its superiors in the
5617    namespace of variables, functions and typedefs.  Return a ..._DECL
5618    node of some kind representing its definition if there is only one
5619    such declaration, or return a TREE_LIST with all the overloaded
5620    definitions if there are many, or return 0 if it is undefined.
5621
5622    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5623    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5624    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5625    Otherwise we prefer non-TYPE_DECLs.
5626
5627    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5628    using IDENTIFIER_CLASS_VALUE.  */
5629
5630 static tree
5631 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5632      tree name;
5633      int prefer_type, nonclass, namespaces_only;
5634 {
5635   tree t;
5636   tree val = NULL_TREE;
5637   int yylex = 0;
5638   tree from_obj = NULL_TREE;
5639   int flags;
5640   int val_is_implicit_typename = 0;
5641
5642   /* Hack: copy flag set by parser, if set. */
5643   if (only_namespace_names)
5644     namespaces_only = 1;
5645
5646   if (prefer_type == -2)
5647     {
5648       extern int looking_for_typename;
5649       tree type = NULL_TREE;
5650
5651       yylex = 1;
5652       prefer_type = looking_for_typename;
5653
5654       flags = lookup_flags (prefer_type, namespaces_only);
5655       /* If the next thing is '<', class templates are types. */
5656       if (looking_for_template)
5657         flags |= LOOKUP_TEMPLATES_EXPECTED;
5658
5659       /* std:: becomes :: for now.  */
5660       if (got_scope == std_node)
5661         got_scope = void_type_node;
5662
5663       if (got_scope)
5664         type = got_scope;
5665       else if (got_object != error_mark_node)
5666         type = got_object;
5667
5668       if (type)
5669         {
5670           if (type == error_mark_node)
5671             return error_mark_node;
5672           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5673             type = TREE_TYPE (type);
5674
5675           if (TYPE_P (type))
5676             type = complete_type (type);
5677
5678           if (TREE_CODE (type) == VOID_TYPE)
5679             type = global_namespace;
5680           if (TREE_CODE (type) == NAMESPACE_DECL)
5681             {
5682               val = make_node (CPLUS_BINDING);
5683               flags |= LOOKUP_COMPLAIN;
5684               if (!qualified_lookup_using_namespace (name, type, val, flags))
5685                 return NULL_TREE;
5686               val = select_decl (val, flags);
5687             }
5688           else if (! IS_AGGR_TYPE (type)
5689                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5690                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5691                    || TREE_CODE (type) == TYPENAME_TYPE)
5692             /* Someone else will give an error about this if needed.  */
5693             val = NULL_TREE;
5694           else if (type == current_class_type)
5695             val = IDENTIFIER_CLASS_VALUE (name);
5696           else
5697             {
5698               val = lookup_member (type, name, 0, prefer_type);
5699               type_access_control (type, val);
5700             }
5701         }
5702       else
5703         val = NULL_TREE;
5704
5705       if (got_scope)
5706         goto done;
5707       else if (got_object && val)
5708         from_obj = val;
5709     }
5710   else
5711     {
5712       flags = lookup_flags (prefer_type, namespaces_only);
5713       /* If we're not parsing, we need to complain. */
5714       flags |= LOOKUP_COMPLAIN;
5715     }
5716
5717   /* First, look in non-namespace scopes.  */
5718
5719   if (current_class_type == NULL_TREE)
5720     nonclass = 1;
5721
5722   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5723     {
5724       tree binding;
5725
5726       if (!LOCAL_BINDING_P (t) && nonclass)
5727         /* We're not looking for class-scoped bindings, so keep going.  */
5728         continue;
5729
5730       /* If this is the kind of thing we're looking for, we're done.  */
5731       if (qualify_lookup (BINDING_VALUE (t), flags))
5732         binding = BINDING_VALUE (t);
5733       else if ((flags & LOOKUP_PREFER_TYPES)
5734                && qualify_lookup (BINDING_TYPE (t), flags))
5735         binding = BINDING_TYPE (t);
5736       else
5737         binding = NULL_TREE;
5738
5739       /* Handle access control on types from enclosing or base classes.  */
5740       if (binding && ! yylex
5741           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5742         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5743
5744       if (binding
5745           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5746         {
5747           if (val_is_implicit_typename && !yylex)
5748             warn_about_implicit_typename_lookup (val, binding);
5749           val = binding;
5750           val_is_implicit_typename
5751             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5752           if (!val_is_implicit_typename)
5753             break;
5754         }
5755     }
5756
5757   /* Now lookup in namespace scopes.  */
5758   if (!val || val_is_implicit_typename)
5759     {
5760       t = unqualified_namespace_lookup (name, flags, 0);
5761       if (t)
5762         {
5763           if (val_is_implicit_typename && !yylex)
5764             warn_about_implicit_typename_lookup (val, t);
5765           val = t;
5766         }
5767     }
5768
5769  done:
5770   if (val)
5771     {
5772       /* This should only warn about types used in qualified-ids.  */
5773       if (from_obj && from_obj != val)
5774         {
5775           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5776               && TREE_CODE (val) == TYPE_DECL
5777               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5778             {
5779               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5780                           name, got_object, TREE_TYPE (from_obj));
5781               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5782                           TREE_TYPE (val));
5783             }
5784
5785           /* We don't change val to from_obj if got_object depends on
5786              template parms because that breaks implicit typename for
5787              destructor calls.  */
5788           if (! uses_template_parms (got_object))
5789             val = from_obj;
5790         }
5791
5792       /* If we have a single function from a using decl, pull it out.  */
5793       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5794         val = OVL_FUNCTION (val);
5795     }
5796   else if (from_obj)
5797     val = from_obj;
5798
5799   return val;
5800 }
5801
5802 tree
5803 lookup_name_nonclass (name)
5804      tree name;
5805 {
5806   return lookup_name_real (name, 0, 1, 0);
5807 }
5808
5809 tree
5810 lookup_function_nonclass (name, args)
5811      tree name;
5812      tree args;
5813 {
5814   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5815 }
5816
5817 tree
5818 lookup_name_namespace_only (name)
5819      tree name;
5820 {
5821   /* type-or-namespace, nonclass, namespace_only */
5822   return lookup_name_real (name, 1, 1, 1);
5823 }
5824
5825 tree
5826 lookup_name (name, prefer_type)
5827      tree name;
5828      int prefer_type;
5829 {
5830   return lookup_name_real (name, prefer_type, 0, 0);
5831 }
5832
5833 /* Similar to `lookup_name' but look only in the innermost non-class
5834    binding level.  */
5835
5836 tree
5837 lookup_name_current_level (name)
5838      tree name;
5839 {
5840   struct binding_level *b;
5841   tree t = NULL_TREE;
5842
5843   b = current_binding_level;
5844   while (b->parm_flag == 2)
5845     b = b->level_chain;
5846
5847   if (b->namespace_p)
5848     {
5849       t = IDENTIFIER_NAMESPACE_VALUE (name);
5850
5851       /* extern "C" function() */
5852       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5853         t = TREE_VALUE (t);
5854     }
5855   else if (IDENTIFIER_BINDING (name)
5856            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
5857     {
5858       while (1)
5859         {
5860           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
5861             return IDENTIFIER_VALUE (name);
5862
5863           if (b->keep == 2)
5864             b = b->level_chain;
5865           else
5866             break;
5867         }
5868     }
5869
5870   return t;
5871 }
5872
5873 /* Like lookup_name_current_level, but for types.  */
5874
5875 tree
5876 lookup_type_current_level (name)
5877      tree name;
5878 {
5879   register tree t = NULL_TREE;
5880
5881   my_friendly_assert (! current_binding_level->namespace_p, 980716);
5882
5883   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5884       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5885     {
5886       struct binding_level *b = current_binding_level;
5887       while (1)
5888         {
5889           if (purpose_member (name, b->type_shadowed))
5890             return REAL_IDENTIFIER_TYPE_VALUE (name);
5891           if (b->keep == 2)
5892             b = b->level_chain;
5893           else
5894             break;
5895         }
5896     }
5897
5898   return t;
5899 }
5900
5901 void
5902 begin_only_namespace_names ()
5903 {
5904   only_namespace_names = 1;
5905 }
5906
5907 void
5908 end_only_namespace_names ()
5909 {
5910   only_namespace_names = 0;
5911 }
5912 \f
5913 /* Arrange for the user to get a source line number, even when the
5914    compiler is going down in flames, so that she at least has a
5915    chance of working around problems in the compiler.  We used to
5916    call error(), but that let the segmentation fault continue
5917    through; now, it's much more passive by asking them to send the
5918    maintainers mail about the problem.  */
5919
5920 static void
5921 signal_catch (sig)
5922      int sig ATTRIBUTE_UNUSED;
5923 {
5924   signal (SIGSEGV, SIG_DFL);
5925 #ifdef SIGIOT
5926   signal (SIGIOT, SIG_DFL);
5927 #endif
5928 #ifdef SIGILL
5929   signal (SIGILL, SIG_DFL);
5930 #endif
5931 #ifdef SIGABRT
5932   signal (SIGABRT, SIG_DFL);
5933 #endif
5934 #ifdef SIGBUS
5935   signal (SIGBUS, SIG_DFL);
5936 #endif
5937   my_friendly_abort (0);
5938 }
5939
5940 /* Push the declarations of builtin types into the namespace.
5941    RID_INDEX, if < RID_MAX is the index of the builtin type
5942    in the array RID_POINTERS.  NAME is the name used when looking
5943    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
5944
5945 static void
5946 record_builtin_type (rid_index, name, type)
5947      enum rid rid_index;
5948      const char *name;
5949      tree type;
5950 {
5951   tree rname = NULL_TREE, tname = NULL_TREE;
5952   tree tdecl = NULL_TREE;
5953
5954   if ((int) rid_index < (int) RID_MAX)
5955     rname = ridpointers[(int) rid_index];
5956   if (name)
5957     tname = get_identifier (name);
5958
5959   TYPE_BUILT_IN (type) = 1;
5960
5961   if (tname)
5962     {
5963       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5964       set_identifier_type_value (tname, NULL_TREE);
5965       if ((int) rid_index < (int) RID_MAX)
5966         /* Built-in types live in the global namespace. */
5967         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5968     }
5969   if (rname != NULL_TREE)
5970     {
5971       if (tname != NULL_TREE)
5972         {
5973           set_identifier_type_value (rname, NULL_TREE);
5974           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5975         }
5976       else
5977         {
5978           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5979           set_identifier_type_value (rname, NULL_TREE);
5980         }
5981     }
5982 }
5983
5984 /* Record one of the standard Java types.
5985  * Declare it as having the given NAME.
5986  * If SIZE > 0, it is the size of one of the integral types;
5987  * otherwise it is the negative of the size of one of the other types.  */
5988
5989 static tree
5990 record_builtin_java_type (name, size)
5991      const char *name;
5992      int size;
5993 {
5994   tree type, decl;
5995   if (size > 0)
5996     type = make_signed_type (size);
5997   else if (size > -32)
5998     { /* "__java_char" or ""__java_boolean". */
5999       type = make_unsigned_type (-size);
6000       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6001     }
6002   else
6003     { /* "__java_float" or ""__java_double". */
6004       type = make_node (REAL_TYPE);
6005       TYPE_PRECISION (type) = - size;
6006       layout_type (type);
6007     }
6008   record_builtin_type (RID_MAX, name, type);
6009   decl = TYPE_NAME (type);
6010
6011   /* Suppress generate debug symbol entries for these types,
6012      since for normal C++ they are just clutter.
6013      However, push_lang_context undoes this if extern "Java" is seen. */
6014   DECL_IGNORED_P (decl) = 1;
6015
6016   TYPE_FOR_JAVA (type) = 1;
6017   return type;
6018 }
6019
6020 /* Push a type into the namespace so that the back-ends ignore it. */
6021
6022 static void
6023 record_unknown_type (type, name)
6024      tree type;
6025      const char *name;
6026 {
6027   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6028   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6029   DECL_IGNORED_P (decl) = 1;
6030   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6031   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6032   TYPE_ALIGN (type) = 1;
6033   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6034 }
6035
6036 /* An string for which we should create an IDENTIFIER_NODE at
6037    startup.  */
6038
6039 typedef struct predefined_identifier
6040 {
6041   /* The name of the identifier.  */
6042   const char *name;
6043   /* The place where the IDENTIFIER_NODE should be stored.  */
6044   tree *node;
6045   /* Non-zero if this is the name of a constructor or destructor.  */
6046   int ctor_or_dtor_p;
6047 } predefined_identifier;
6048
6049 /* Create all the predefined identifiers.  */
6050
6051 static void
6052 initialize_predefined_identifiers ()
6053 {
6054   struct predefined_identifier *pid;
6055
6056   /* A table of identifiers to create at startup.  */
6057   static predefined_identifier predefined_identifiers[] = {
6058     { "C++", &lang_name_cplusplus, 0 },
6059     { "C", &lang_name_c, 0 },
6060     { "Java", &lang_name_java, 0 },
6061     { CTOR_NAME, &ctor_identifier, 1 },
6062     { "__base_ctor", &base_ctor_identifier, 1 },
6063     { "__comp_ctor", &complete_ctor_identifier, 1 },
6064     { DTOR_NAME, &dtor_identifier, 1 },
6065     { "__comp_dtor", &complete_dtor_identifier, 1 },
6066     { "__base_dtor", &base_dtor_identifier, 1 },
6067     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6068     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6069     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6070     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6071     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6072     { "nelts", &nelts_identifier, 0 },
6073     { THIS_NAME, &this_identifier, 0 },
6074     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6075     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6076     { "_vptr", &vptr_identifier, 0 },
6077     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6078     { "__vtt_parm", &vtt_parm_identifier, 0 },
6079     { NULL, NULL, 0 }
6080   };
6081
6082   for (pid = predefined_identifiers; pid->name; ++pid)
6083     {
6084       *pid->node = get_identifier (pid->name);
6085       if (pid->ctor_or_dtor_p)
6086         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6087     }
6088 }
6089
6090 /* Create the predefined scalar types of C,
6091    and some nodes representing standard constants (0, 1, (void *)0).
6092    Initialize the global binding level.
6093    Make definitions for built-in primitive functions.  */
6094
6095 void
6096 init_decl_processing ()
6097 {
6098   tree fields[20];
6099   int wchar_type_size;
6100   tree array_domain_type;
6101
6102   /* Check to see that the user did not specify an invalid combination
6103      of command-line options.  */
6104   if (flag_new_abi && !flag_vtable_thunks)
6105     fatal ("the new ABI requires vtable thunks");
6106
6107   /* Create all the identifiers we need.  */
6108   initialize_predefined_identifiers ();
6109
6110   /* Let the back-end now how to save and restore language-specific
6111      per-function globals.  */
6112   init_lang_status = &push_cp_function_context;
6113   free_lang_status = &pop_cp_function_context;
6114   mark_lang_status = &mark_cp_function_context;
6115
6116   cp_parse_init ();
6117   init_decl2 ();
6118   init_pt ();
6119
6120   /* Create the global variables.  */
6121   push_to_top_level ();
6122
6123   /* Enter the global namespace. */
6124   my_friendly_assert (global_namespace == NULL_TREE, 375);
6125   push_namespace (get_identifier ("::"));
6126   global_namespace = current_namespace;
6127   current_lang_name = NULL_TREE;
6128
6129   /* Adjust various flags based on command-line settings.  */
6130   if (flag_strict_prototype == 2)
6131     flag_strict_prototype = pedantic;
6132   if (! flag_permissive && ! pedantic)
6133     flag_pedantic_errors = 1;
6134   if (!flag_no_inline)
6135     flag_inline_trees = 1;
6136
6137   strict_prototypes_lang_c = flag_strict_prototype;
6138
6139   /* Initially, C.  */
6140   current_lang_name = lang_name_c;
6141
6142   current_function_decl = NULL_TREE;
6143   current_binding_level = NULL_BINDING_LEVEL;
6144   free_binding_level = NULL_BINDING_LEVEL;
6145
6146   /* Because most segmentation signals can be traced back into user
6147      code, catch them and at least give the user a chance of working
6148      around compiler bugs.  */
6149   signal (SIGSEGV, signal_catch);
6150
6151   /* We will also catch aborts in the back-end through signal_catch and
6152      give the user a chance to see where the error might be, and to defeat
6153      aborts in the back-end when there have been errors previously in their
6154      code.  */
6155 #ifdef SIGIOT
6156   signal (SIGIOT, signal_catch);
6157 #endif
6158 #ifdef SIGILL
6159   signal (SIGILL, signal_catch);
6160 #endif
6161 #ifdef SIGABRT
6162   signal (SIGABRT, signal_catch);
6163 #endif
6164 #ifdef SIGBUS
6165   signal (SIGBUS, signal_catch);
6166 #endif
6167
6168   build_common_tree_nodes (flag_signed_char);
6169
6170   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6171   TREE_TYPE (error_mark_list) = error_mark_node;
6172
6173   /* Make the binding_level structure for global names.  */
6174   pushlevel (0);
6175   global_binding_level = current_binding_level;
6176   /* The global level is the namespace level of ::.  */
6177   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6178   declare_namespace_level ();
6179
6180   /* Define `int' and `char' first so that dbx will output them first.  */
6181   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6182   record_builtin_type (RID_CHAR, "char", char_type_node);
6183
6184   /* `signed' is the same as `int' */
6185   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6186   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6187   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6188   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6189   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6190   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6191   record_builtin_type (RID_MAX, "long long unsigned int",
6192                        long_long_unsigned_type_node);
6193   record_builtin_type (RID_MAX, "long long unsigned",
6194                        long_long_unsigned_type_node);
6195   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6196   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6197   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6198
6199   ptrdiff_type_node
6200     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6201
6202   /* Define both `signed char' and `unsigned char'.  */
6203   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6204   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6205
6206   /* `unsigned long' is the standard type for sizeof.
6207      Note that stddef.h uses `unsigned long',
6208      and this must agree, even if long and int are the same size.  */
6209   set_sizetype
6210     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6211
6212   /* Create the widest literal types. */
6213   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6214   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6215                         widest_integer_literal_type_node));
6216
6217   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6218   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6219                         widest_unsigned_literal_type_node));
6220
6221   /* These are types that type_for_size and type_for_mode use.  */
6222   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6223   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6224   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6225   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6226 #if HOST_BITS_PER_WIDE_INT >= 64
6227   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6228 #endif
6229   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6230   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6231   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6232   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6233 #if HOST_BITS_PER_WIDE_INT >= 64
6234   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6235 #endif
6236
6237   build_common_tree_nodes_2 (flag_short_double);
6238
6239   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6240   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6241   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6242   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6243   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6244   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6245   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6246   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6247
6248   integer_two_node = build_int_2 (2, 0);
6249   TREE_TYPE (integer_two_node) = integer_type_node;
6250   integer_three_node = build_int_2 (3, 0);
6251   TREE_TYPE (integer_three_node) = integer_type_node;
6252
6253   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6254   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6255   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6256   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6257   TYPE_PRECISION (boolean_type_node) = 1;
6258   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6259   boolean_false_node = build_int_2 (0, 0);
6260   TREE_TYPE (boolean_false_node) = boolean_type_node;
6261   boolean_true_node = build_int_2 (1, 0);
6262   TREE_TYPE (boolean_true_node) = boolean_type_node;
6263
6264   signed_size_zero_node = build_int_2 (0, 0);
6265   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6266   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6267   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6268
6269   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6270                         complex_integer_type_node));
6271   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6272                         complex_float_type_node));
6273   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6274                         complex_double_type_node));
6275   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6276                         complex_long_double_type_node));
6277
6278   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6279
6280   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6281   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6282   TREE_PARMLIST (void_list_node) = 1;
6283
6284   /* Used for expressions that do nothing, but are not errors.  */
6285   void_zero_node = build_int_2 (0, 0);
6286   TREE_TYPE (void_zero_node) = void_type_node;
6287
6288   string_type_node = build_pointer_type (char_type_node);
6289   const_string_type_node
6290     = build_pointer_type (build_qualified_type (char_type_node,
6291                                                 TYPE_QUAL_CONST));
6292   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6293 #if 0
6294   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6295 #endif
6296
6297   /* Make a type to be the domain of a few array types
6298      whose domains don't really matter.
6299      200 is small enough that it always fits in size_t.  */
6300   array_domain_type = build_index_type (build_int_2 (200, 0));
6301
6302   /* Make a type for arrays of characters.
6303      With luck nothing will ever really depend on the length of this
6304      array type.  */
6305   char_array_type_node
6306     = build_array_type (char_type_node, array_domain_type);
6307   /* Likewise for arrays of ints.  */
6308   int_array_type_node
6309     = build_array_type (integer_type_node, array_domain_type);
6310
6311   if (flag_new_abi)
6312     delta_type_node = ptrdiff_type_node;
6313   else if (flag_huge_objects)
6314     delta_type_node = long_integer_type_node;
6315   else
6316     delta_type_node = short_integer_type_node;
6317
6318   if (flag_new_abi)
6319     vtable_index_type = ptrdiff_type_node;
6320   else
6321     vtable_index_type = delta_type_node;
6322
6323   default_function_type
6324     = build_function_type (integer_type_node, NULL_TREE);
6325
6326   ptr_type_node = build_pointer_type (void_type_node);
6327   const_ptr_type_node
6328     = build_pointer_type (build_qualified_type (void_type_node,
6329                                                 TYPE_QUAL_CONST));
6330   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6331   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6332   lang_type_promotes_to = convert_type_from_ellipsis;
6333
6334   void_ftype_ptr
6335     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6336
6337   /* C++ extensions */
6338
6339   unknown_type_node = make_node (UNKNOWN_TYPE);
6340   record_unknown_type (unknown_type_node, "unknown type");
6341
6342   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6343   TREE_TYPE (unknown_type_node) = unknown_type_node;
6344
6345   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6346
6347   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6348      result.  */
6349   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6350   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6351
6352   /* This is special for C++ so functions can be overloaded.  */
6353   wchar_type_node = get_identifier (flag_short_wchar
6354                                     ? "short unsigned int"
6355                                     : WCHAR_TYPE);
6356   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6357   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6358   signed_wchar_type_node = make_signed_type (wchar_type_size);
6359   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6360   wchar_type_node
6361     = TREE_UNSIGNED (wchar_type_node)
6362       ? unsigned_wchar_type_node
6363       : signed_wchar_type_node;
6364   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6365
6366   /* Artificial declaration of wchar_t -- can be bashed */
6367   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6368                                 wchar_type_node);
6369   pushdecl (wchar_decl_node);
6370
6371   /* This is for wide string constants.  */
6372   wchar_array_type_node
6373     = build_array_type (wchar_type_node, array_domain_type);
6374
6375   if (flag_vtable_thunks)
6376     {
6377       /* Make sure we get a unique function type, so we can give
6378          its pointer type a name.  (This wins for gdb.) */
6379       tree vfunc_type = make_node (FUNCTION_TYPE);
6380       TREE_TYPE (vfunc_type) = integer_type_node;
6381       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6382       layout_type (vfunc_type);
6383
6384       vtable_entry_type = build_pointer_type (vfunc_type);
6385     }
6386   else
6387     {
6388       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6389       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6390                               delta_type_node);
6391       fields[1] = build_decl (FIELD_DECL, index_identifier,
6392                               delta_type_node);
6393       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6394                               ptr_type_node);
6395       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6396                            double_type_node);
6397
6398       /* Make this part of an invisible union.  */
6399       fields[3] = copy_node (fields[2]);
6400       TREE_TYPE (fields[3]) = delta_type_node;
6401       DECL_NAME (fields[3]) = delta2_identifier;
6402       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6403       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6404       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6405       TREE_UNSIGNED (fields[3]) = 0;
6406       TREE_CHAIN (fields[2]) = fields[3];
6407       vtable_entry_type = build_qualified_type (vtable_entry_type,
6408                                                 TYPE_QUAL_CONST);
6409     }
6410   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6411
6412   vtbl_type_node
6413     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6414   layout_type (vtbl_type_node);
6415   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6416   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6417   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6418   layout_type (vtbl_ptr_type_node);
6419   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6420
6421   std_node = build_decl (NAMESPACE_DECL,
6422                          get_identifier (flag_honor_std ? "fake std":"std"),
6423                          void_type_node);
6424   pushdecl (std_node);
6425
6426   if (flag_new_abi)
6427     {
6428       push_namespace (get_identifier ("__cxxabiv1"));
6429       abi_node = current_namespace;
6430       pop_namespace ();
6431     }
6432
6433   global_type_node = make_node (LANG_TYPE);
6434   record_unknown_type (global_type_node, "global type");
6435
6436   /* Now, C++.  */
6437   current_lang_name = lang_name_cplusplus;
6438
6439   {
6440     tree bad_alloc_type_node, newtype, deltype;
6441     if (flag_honor_std)
6442       push_namespace (get_identifier ("std"));
6443     bad_alloc_type_node = xref_tag
6444       (class_type_node, get_identifier ("bad_alloc"), 1);
6445     if (flag_honor_std)
6446       pop_namespace ();
6447     newtype = build_exception_variant
6448       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6449     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6450     push_cp_library_fn (ansi_opname[(int) NEW_EXPR], newtype);
6451     push_cp_library_fn (ansi_opname[(int) VEC_NEW_EXPR], newtype);
6452     global_delete_fndecl = push_cp_library_fn (ansi_opname[(int) DELETE_EXPR],
6453                                                deltype);
6454     push_cp_library_fn (ansi_opname[(int) VEC_DELETE_EXPR], deltype);
6455   }
6456
6457   abort_fndecl
6458     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6459
6460   /* Perform other language dependent initializations.  */
6461   init_class_processing ();
6462   init_init_processing ();
6463   init_search_processing ();
6464   init_rtti_processing ();
6465
6466   if (flag_exceptions)
6467     init_exception_processing ();
6468   if (flag_no_inline)
6469     {
6470       flag_inline_functions = 0;
6471     }
6472
6473   if (! supports_one_only ())
6474     flag_weak = 0;
6475
6476   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6477   make_fname_decl = cp_make_fname_decl;
6478   declare_function_name ();
6479
6480   /* Prepare to check format strings against argument lists.  */
6481   init_function_format_info ();
6482
6483   /* Show we use EH for cleanups.  */
6484   using_eh_for_cleanups ();
6485
6486   print_error_function = lang_print_error_function;
6487   lang_get_alias_set = &c_get_alias_set;
6488   valid_lang_attribute = cp_valid_lang_attribute;
6489
6490   /* Maintain consistency.  Perhaps we should just complain if they
6491      say -fwritable-strings?  */
6492   if (flag_writable_strings)
6493     flag_const_strings = 0;
6494
6495   /* Add GC roots for all of our global variables.  */
6496   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6497   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6498   ggc_add_tree_root (&integer_three_node, 1);
6499   ggc_add_tree_root (&integer_two_node, 1);
6500   ggc_add_tree_root (&signed_size_zero_node, 1);
6501   ggc_add_tree_root (&size_one_node, 1);
6502   ggc_add_tree_root (&size_zero_node, 1);
6503   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6504                 mark_binding_level);
6505   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6506   ggc_add_tree_root (&static_ctors, 1);
6507   ggc_add_tree_root (&static_dtors, 1);
6508   ggc_add_tree_root (&lastiddecl, 1);
6509
6510   ggc_add_tree_root (&last_function_parm_tags, 1);
6511   ggc_add_tree_root (&current_function_return_value, 1);
6512   ggc_add_tree_root (&current_function_parms, 1);
6513   ggc_add_tree_root (&current_function_parm_tags, 1);
6514   ggc_add_tree_root (&last_function_parms, 1);
6515   ggc_add_tree_root (&error_mark_list, 1);
6516
6517   ggc_add_tree_root (&global_namespace, 1);
6518   ggc_add_tree_root (&global_type_node, 1);
6519   ggc_add_tree_root (&anonymous_namespace_name, 1);
6520
6521   ggc_add_tree_root (&got_object, 1);
6522   ggc_add_tree_root (&got_scope, 1);
6523
6524   ggc_add_tree_root (&current_lang_name, 1);
6525   ggc_add_tree_root (&static_aggregates, 1);
6526 }
6527
6528 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6529    decl, NAME is the initialization string and TYPE_DEP indicates whether
6530    NAME depended on the type of the function. We make use of that to detect
6531    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6532    the function before emitting any of it, we don't need to treat the
6533    VAR_DECL specially. We can decide whether to emit it later, if it was
6534    used.  */
6535
6536 static tree
6537 cp_make_fname_decl (id, name, type_dep)
6538      tree id;
6539      const char *name;
6540      int type_dep;
6541 {
6542   tree decl, type, init;
6543   size_t length = strlen (name);
6544   tree domain = NULL_TREE;
6545
6546   if (!processing_template_decl)
6547     type_dep = 0;
6548   if (!type_dep)
6549     domain = build_index_type (build_int_2 (length, 0));
6550
6551   type =  build_cplus_array_type
6552           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6553            domain);
6554
6555   decl = build_decl (VAR_DECL, id, type);
6556   TREE_STATIC (decl) = 1;
6557   TREE_READONLY (decl) = 1;
6558   DECL_SOURCE_LINE (decl) = 0;
6559   DECL_ARTIFICIAL (decl) = 1;
6560   DECL_IN_SYSTEM_HEADER (decl) = 1;
6561   pushdecl (decl);
6562   if (processing_template_decl)
6563     decl = push_template_decl (decl);
6564   if (type_dep)
6565     {
6566       init = build (FUNCTION_NAME, type);
6567       DECL_PRETTY_FUNCTION_P (decl) = 1;
6568     }
6569   else
6570     {
6571       init = build_string (length + 1, name);
6572       TREE_TYPE (init) = type;
6573     }
6574   DECL_INITIAL (decl) = init;
6575   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6576
6577   /* We will have to make sure we only emit this, if it is actually used. */
6578   return decl;
6579 }
6580
6581 /* Function to print any language-specific context for an error message.  */
6582
6583 static void
6584 lang_print_error_function (file)
6585      const char *file;
6586 {
6587   default_print_error_function (file);
6588   maybe_print_template_context ();
6589 }
6590
6591 /* Entry point for the benefit of c_common_nodes_and_builtins.
6592
6593    Make a definition for a builtin function named NAME and whose data type
6594    is TYPE.  TYPE should be a function type with argument types.
6595
6596    CLASS and CODE tell later passes how to compile calls to this function.
6597    See tree.h for possible values.
6598
6599    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6600    the name to be called if we can't opencode the function.  */
6601
6602 tree
6603 builtin_function (name, type, code, class, libname)
6604      const char *name;
6605      tree type;
6606      int code;
6607      enum built_in_class class;
6608      const char *libname;
6609 {
6610   tree decl = build_library_fn_1 (get_identifier (name), type);
6611   DECL_BUILT_IN_CLASS (decl) = class;
6612   DECL_FUNCTION_CODE (decl) = code;
6613
6614   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6615
6616   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6617      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6618      function in the namespace.  */
6619   pushdecl (decl);
6620   if (libname)
6621     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6622   make_function_rtl (decl);
6623   return decl;
6624 }
6625
6626 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6627    function.  Not called directly.  */
6628
6629 static tree
6630 build_library_fn_1 (name, type)
6631      tree name;
6632      tree type;
6633 {
6634   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6635   DECL_EXTERNAL (fn) = 1;
6636   TREE_PUBLIC (fn) = 1;
6637   DECL_ARTIFICIAL (fn) = 1;
6638   TREE_NOTHROW (fn) = 1;
6639   return fn;
6640 }
6641
6642 /* Returns the _DECL for a library function with C linkage.
6643    We assume that such functions never throw; if this is incorrect,
6644    callers should unset TREE_NOTHROW.  */
6645
6646 tree
6647 build_library_fn (name, type)
6648      tree name;
6649      tree type;
6650 {
6651   tree fn = build_library_fn_1 (name, type);
6652   make_function_rtl (fn);
6653   return fn;
6654 }
6655
6656 /* Returns the _DECL for a library function with C++ linkage.  */
6657
6658 tree
6659 build_cp_library_fn (name, type)
6660      tree name;
6661      tree type;
6662 {
6663   tree fn = build_library_fn_1 (name, type);
6664   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6665   set_mangled_name_for_decl (fn);
6666   make_function_rtl (fn);
6667   return fn;
6668 }
6669
6670 /* Like build_library_fn, but takes a C string instead of an
6671    IDENTIFIER_NODE.  */
6672
6673 tree
6674 build_library_fn_ptr (name, type)
6675      const char *name;
6676      tree type;
6677 {
6678   return build_library_fn (get_identifier (name), type);
6679 }
6680
6681 /* Like build_cp_library_fn, but takes a C string instead of an
6682    IDENTIFIER_NODE.  */
6683
6684 tree
6685 build_cp_library_fn_ptr (name, type)
6686      const char *name;
6687      tree type;
6688 {
6689   return build_cp_library_fn (get_identifier (name), type);
6690 }
6691
6692 /* Like build_library_fn, but also pushes the function so that we will
6693    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6694
6695 tree
6696 push_library_fn (name, type)
6697      tree name, type;
6698 {
6699   tree fn = build_library_fn (name, type);
6700   pushdecl_top_level (fn);
6701   return fn;
6702 }
6703
6704 /* Like build_cp_library_fn, but also pushes the function so that it
6705    will be found by normal lookup.  */
6706
6707 tree
6708 push_cp_library_fn (name, type)
6709      tree name;
6710      tree type;
6711 {
6712   tree fn = build_cp_library_fn (name, type);
6713   pushdecl (fn);
6714   return fn;
6715 }
6716
6717 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6718    a FUNCTION_TYPE.  */
6719
6720 tree
6721 push_void_library_fn (name, parmtypes)
6722      tree name, parmtypes;
6723 {
6724   tree type = build_function_type (void_type_node, parmtypes);
6725   return push_library_fn (name, type);
6726 }
6727
6728 /* Like push_library_fn, but also note that this function throws
6729    and does not return.  Used for __throw_foo and the like.  */
6730
6731 tree
6732 push_throw_library_fn (name, type)
6733      tree name, type;
6734 {
6735   tree fn = push_library_fn (name, type);
6736   TREE_THIS_VOLATILE (fn) = 1;
6737   TREE_NOTHROW (fn) = 0;
6738   return fn;
6739 }
6740 \f
6741 /* When we call finish_struct for an anonymous union, we create
6742    default copy constructors and such.  But, an anonymous union
6743    shouldn't have such things; this function undoes the damage to the
6744    anonymous union type T.
6745
6746    (The reason that we create the synthesized methods is that we don't
6747    distinguish `union { int i; }' from `typedef union { int i; } U'.
6748    The first is an anonymous union; the second is just an ordinary
6749    union type.)  */
6750
6751 void
6752 fixup_anonymous_aggr (t)
6753      tree t;
6754 {
6755   tree *q;
6756
6757   /* Wipe out memory of synthesized methods */
6758   TYPE_HAS_CONSTRUCTOR (t) = 0;
6759   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6760   TYPE_HAS_INIT_REF (t) = 0;
6761   TYPE_HAS_CONST_INIT_REF (t) = 0;
6762   TYPE_HAS_ASSIGN_REF (t) = 0;
6763   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6764
6765   /* Splice the implicitly generated functions out of the TYPE_METHODS
6766      list.  */
6767   q = &TYPE_METHODS (t);
6768   while (*q)
6769     {
6770       if (DECL_ARTIFICIAL (*q))
6771         *q = TREE_CHAIN (*q);
6772       else
6773         q = &TREE_CHAIN (*q);
6774     }
6775
6776   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6777   if (TYPE_METHODS (t))
6778     error ("an anonymous union cannot have function members");
6779 }
6780
6781 /* Make sure that a declaration with no declarator is well-formed, i.e.
6782    just defines a tagged type or anonymous union.
6783
6784    Returns the type defined, if any.  */
6785
6786 tree
6787 check_tag_decl (declspecs)
6788      tree declspecs;
6789 {
6790   int found_type = 0;
6791   int saw_friend = 0;
6792   tree ob_modifier = NULL_TREE;
6793   register tree link;
6794   register tree t = NULL_TREE;
6795
6796   for (link = declspecs; link; link = TREE_CHAIN (link))
6797     {
6798       register tree value = TREE_VALUE (link);
6799
6800       if (TYPE_P (value)
6801           || (TREE_CODE (value) == IDENTIFIER_NODE
6802               && IDENTIFIER_GLOBAL_VALUE (value)
6803               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6804         {
6805           ++found_type;
6806
6807           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6808             {
6809               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6810               t = value;
6811             }
6812         }
6813       else if (value == ridpointers[(int) RID_FRIEND])
6814         {
6815           if (current_class_type == NULL_TREE
6816               || current_scope () != current_class_type)
6817             ob_modifier = value;
6818           else
6819             saw_friend = 1;
6820         }
6821       else if (value == ridpointers[(int) RID_STATIC]
6822                || value == ridpointers[(int) RID_EXTERN]
6823                || value == ridpointers[(int) RID_AUTO]
6824                || value == ridpointers[(int) RID_REGISTER]
6825                || value == ridpointers[(int) RID_INLINE]
6826                || value == ridpointers[(int) RID_VIRTUAL]
6827                || value == ridpointers[(int) RID_CONST]
6828                || value == ridpointers[(int) RID_VOLATILE]
6829                || value == ridpointers[(int) RID_EXPLICIT])
6830         ob_modifier = value;
6831     }
6832
6833   if (found_type > 1)
6834     error ("multiple types in one declaration");
6835
6836   if (t == NULL_TREE && ! saw_friend)
6837     pedwarn ("declaration does not declare anything");
6838
6839   /* Check for an anonymous union.  We're careful
6840      accessing TYPE_IDENTIFIER because some built-in types, like
6841      pointer-to-member types, do not have TYPE_NAME.  */
6842   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6843            && TYPE_NAME (t)
6844            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6845     {
6846       /* Anonymous unions are objects, so they can have specifiers.  */;
6847       SET_ANON_AGGR_TYPE_P (t);
6848
6849       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6850         pedwarn ("ISO C++ prohibits anonymous structs");
6851     }
6852
6853   else if (ob_modifier)
6854     {
6855       if (ob_modifier == ridpointers[(int) RID_INLINE]
6856           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6857         cp_error ("`%D' can only be specified for functions", ob_modifier);
6858       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6859         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6860       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6861         cp_error ("`%D' can only be specified for constructors",
6862                   ob_modifier);
6863       else
6864         cp_error ("`%D' can only be specified for objects and functions",
6865                   ob_modifier);
6866     }
6867
6868   return t;
6869 }
6870
6871 /* Called when a declaration is seen that contains no names to declare.
6872    If its type is a reference to a structure, union or enum inherited
6873    from a containing scope, shadow that tag name for the current scope
6874    with a forward reference.
6875    If its type defines a new named structure or union
6876    or defines an enum, it is valid but we need not do anything here.
6877    Otherwise, it is an error.
6878
6879    C++: may have to grok the declspecs to learn about static,
6880    complain for anonymous unions.  */
6881
6882 void
6883 shadow_tag (declspecs)
6884      tree declspecs;
6885 {
6886   tree t = check_tag_decl (declspecs);
6887
6888   if (t)
6889     maybe_process_partial_specialization (t);
6890
6891   /* This is where the variables in an anonymous union are
6892      declared.  An anonymous union declaration looks like:
6893      union { ... } ;
6894      because there is no declarator after the union, the parser
6895      sends that declaration here.  */
6896   if (t && ANON_AGGR_TYPE_P (t))
6897     {
6898       fixup_anonymous_aggr (t);
6899
6900       if (TYPE_FIELDS (t))
6901         {
6902           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6903                                       NULL_TREE);
6904           finish_anon_union (decl);
6905         }
6906     }
6907 }
6908 \f
6909 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6910
6911 tree
6912 groktypename (typename)
6913      tree typename;
6914 {
6915   if (TREE_CODE (typename) != TREE_LIST)
6916     return typename;
6917   return grokdeclarator (TREE_VALUE (typename),
6918                          TREE_PURPOSE (typename),
6919                          TYPENAME, 0, NULL_TREE);
6920 }
6921
6922 /* Decode a declarator in an ordinary declaration or data definition.
6923    This is called as soon as the type information and variable name
6924    have been parsed, before parsing the initializer if any.
6925    Here we create the ..._DECL node, fill in its type,
6926    and put it on the list of decls for the current context.
6927    The ..._DECL node is returned as the value.
6928
6929    Exception: for arrays where the length is not specified,
6930    the type is left null, to be filled in by `cp_finish_decl'.
6931
6932    Function definitions do not come here; they go to start_function
6933    instead.  However, external and forward declarations of functions
6934    do go through here.  Structure field declarations are done by
6935    grokfield and not through here.  */
6936
6937 tree
6938 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6939      tree declarator, declspecs;
6940      int initialized;
6941      tree attributes, prefix_attributes;
6942 {
6943   register tree decl;
6944   register tree type, tem;
6945   tree context;
6946   extern int have_extern_spec;
6947   extern int used_extern_spec;
6948   tree attrlist;
6949
6950 #if 0
6951   /* See code below that used this.  */
6952   int init_written = initialized;
6953 #endif
6954
6955   /* This should only be done once on the top most decl.  */
6956   if (have_extern_spec && !used_extern_spec)
6957     {
6958       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6959                                   declspecs);
6960       used_extern_spec = 1;
6961     }
6962
6963   if (attributes || prefix_attributes)
6964     attrlist = build_tree_list (attributes, prefix_attributes);
6965   else
6966     attrlist = NULL_TREE;
6967
6968   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6969                          attrlist);
6970
6971   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6972     return NULL_TREE;
6973
6974   type = TREE_TYPE (decl);
6975
6976   if (type == error_mark_node)
6977     return NULL_TREE;
6978
6979   context = DECL_CONTEXT (decl);
6980
6981   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
6982       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
6983     {
6984       /* When parsing the initializer, lookup should use the object's
6985          namespace. */
6986       push_decl_namespace (context);
6987     }
6988
6989   /* We are only interested in class contexts, later. */
6990   if (context && TREE_CODE (context) == NAMESPACE_DECL)
6991     context = NULL_TREE;
6992
6993   if (initialized)
6994     /* Is it valid for this decl to have an initializer at all?
6995        If not, set INITIALIZED to zero, which will indirectly
6996        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6997     switch (TREE_CODE (decl))
6998       {
6999       case TYPE_DECL:
7000         /* typedef foo = bar  means give foo the same type as bar.
7001            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7002            Any other case of an initialization in a TYPE_DECL is an error.  */
7003         if (pedantic || list_length (declspecs) > 1)
7004           {
7005             cp_error ("typedef `%D' is initialized", decl);
7006             initialized = 0;
7007           }
7008         break;
7009
7010       case FUNCTION_DECL:
7011         cp_error ("function `%#D' is initialized like a variable", decl);
7012         initialized = 0;
7013         break;
7014
7015       default:
7016         break;
7017       }
7018
7019   if (initialized)
7020     {
7021       if (! toplevel_bindings_p ()
7022           && DECL_EXTERNAL (decl))
7023         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7024                     decl);
7025       DECL_EXTERNAL (decl) = 0;
7026       if (toplevel_bindings_p ())
7027         TREE_STATIC (decl) = 1;
7028
7029       /* Tell `pushdecl' this is an initialized decl
7030          even though we don't yet have the initializer expression.
7031          Also tell `cp_finish_decl' it may store the real initializer.  */
7032       DECL_INITIAL (decl) = error_mark_node;
7033     }
7034
7035 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7036   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7037 #endif
7038
7039   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7040   cplus_decl_attributes (decl, attributes, prefix_attributes);
7041
7042   if (context && COMPLETE_TYPE_P (complete_type (context)))
7043     {
7044       push_nested_class (context, 2);
7045
7046       if (TREE_CODE (decl) == VAR_DECL)
7047         {
7048           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7049           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7050             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7051           else
7052             {
7053               if (DECL_CONTEXT (field) != context)
7054                 {
7055                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7056                               DECL_CONTEXT (field), DECL_NAME (decl),
7057                               context, DECL_NAME (decl));
7058                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7059                 }
7060               /* Static data member are tricky; an in-class initialization
7061                  still doesn't provide a definition, so the in-class
7062                  declaration will have DECL_EXTERNAL set, but will have an
7063                  initialization.  Thus, duplicate_decls won't warn
7064                  about this situation, and so we check here.  */
7065               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7066                 cp_error ("duplicate initialization of %D", decl);
7067               if (duplicate_decls (decl, field))
7068                 decl = field;
7069             }
7070         }
7071       else
7072         {
7073           tree field = check_classfn (context, decl);
7074           if (field && duplicate_decls (decl, field))
7075             decl = field;
7076         }
7077
7078       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7079       DECL_IN_AGGR_P (decl) = 0;
7080       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7081           || CLASSTYPE_USE_TEMPLATE (context))
7082         {
7083           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7084           /* [temp.expl.spec] An explicit specialization of a static data
7085              member of a template is a definition if the declaration
7086              includes an initializer; otherwise, it is a declaration.
7087
7088              We check for processing_specialization so this only applies
7089              to the new specialization syntax.  */
7090           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7091             DECL_EXTERNAL (decl) = 1;
7092         }
7093
7094       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7095         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7096                     decl);
7097     }
7098
7099   /* Enter this declaration into the symbol table.  */
7100   tem = maybe_push_decl (decl);
7101
7102   if (processing_template_decl)
7103     tem = push_template_decl (tem);
7104
7105 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7106   /* Tell the back-end to use or not use .common as appropriate.  If we say
7107      -fconserve-space, we want this to save .data space, at the expense of
7108      wrong semantics.  If we say -fno-conserve-space, we want this to
7109      produce errors about redefs; to do this we force variables into the
7110      data segment.  */
7111   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7112 #endif
7113
7114   if (! processing_template_decl)
7115     start_decl_1 (tem);
7116
7117   return tem;
7118 }
7119
7120 void
7121 start_decl_1 (decl)
7122      tree decl;
7123 {
7124   tree type = TREE_TYPE (decl);
7125   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7126
7127   if (type == error_mark_node)
7128     return;
7129
7130   /* If this type of object needs a cleanup, but we're not allowed to
7131      add any more objects with cleanups to the current scope, create a
7132      new binding level.  */
7133   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7134       && current_binding_level->more_cleanups_ok == 0)
7135     {
7136       keep_next_level (2);
7137       pushlevel (1);
7138       clear_last_expr ();
7139       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7140     }
7141
7142   if (initialized)
7143     /* Is it valid for this decl to have an initializer at all?
7144        If not, set INITIALIZED to zero, which will indirectly
7145        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7146     {
7147       /* Don't allow initializations for incomplete types except for
7148          arrays which might be completed by the initialization.  */
7149       if (COMPLETE_TYPE_P (complete_type (type)))
7150         ;                       /* A complete type is ok.  */
7151       else if (TREE_CODE (type) != ARRAY_TYPE)
7152         {
7153           cp_error ("variable `%#D' has initializer but incomplete type",
7154                     decl);
7155           initialized = 0;
7156           type = TREE_TYPE (decl) = error_mark_node;
7157         }
7158       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7159         {
7160           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7161             cp_error ("elements of array `%#D' have incomplete type", decl);
7162           /* else we already gave an error in start_decl.  */
7163           initialized = 0;
7164         }
7165     }
7166
7167   if (!initialized
7168       && TREE_CODE (decl) != TYPE_DECL
7169       && TREE_CODE (decl) != TEMPLATE_DECL
7170       && type != error_mark_node
7171       && IS_AGGR_TYPE (type)
7172       && ! DECL_EXTERNAL (decl))
7173     {
7174       if ((! processing_template_decl || ! uses_template_parms (type))
7175           && !COMPLETE_TYPE_P (complete_type (type)))
7176         {
7177           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7178                  decl);
7179           /* Change the type so that assemble_variable will give
7180              DECL an rtl we can live with: (mem (const_int 0)).  */
7181           type = TREE_TYPE (decl) = error_mark_node;
7182         }
7183       else
7184         {
7185           /* If any base type in the hierarchy of TYPE needs a constructor,
7186              then we set initialized to 1.  This way any nodes which are
7187              created for the purposes of initializing this aggregate
7188              will live as long as it does.  This is necessary for global
7189              aggregates which do not have their initializers processed until
7190              the end of the file.  */
7191           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7192         }
7193     }
7194
7195   if (! initialized)
7196     DECL_INITIAL (decl) = NULL_TREE;
7197 }
7198
7199 /* Handle initialization of references.
7200    These three arguments are from `cp_finish_decl', and have the
7201    same meaning here that they do there.
7202
7203    Quotes on semantics can be found in ARM 8.4.3.  */
7204
7205 static void
7206 grok_reference_init (decl, type, init)
7207      tree decl, type, init;
7208 {
7209   tree tmp;
7210
7211   if (init == NULL_TREE)
7212     {
7213       if ((DECL_LANG_SPECIFIC (decl) == 0
7214            || DECL_IN_AGGR_P (decl) == 0)
7215           && ! DECL_THIS_EXTERN (decl))
7216         cp_error ("`%D' declared as reference but not initialized", decl);
7217       return;
7218     }
7219
7220   if (init == error_mark_node)
7221     return;
7222
7223   if (TREE_CODE (init) == CONSTRUCTOR)
7224     {
7225       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7226       return;
7227     }
7228
7229   if (TREE_CODE (init) == TREE_LIST)
7230     init = build_compound_expr (init);
7231
7232   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7233     init = convert_from_reference (init);
7234
7235   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7236       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7237     {
7238       /* Note: default conversion is only called in very special cases.  */
7239       init = default_conversion (init);
7240     }
7241
7242   /* Convert INIT to the reference type TYPE.  This may involve the
7243      creation of a temporary, whose lifetime must be the same as that
7244      of the reference.  If so, a DECL_STMT for the temporary will be
7245      added just after the DECL_STMT for DECL.  That's why we don't set
7246      DECL_INITIAL for local references (instead assigning to them
7247      explicitly); we need to allow the temporary to be initialized
7248      first.  */
7249   tmp = convert_to_reference
7250     (type, init, CONV_IMPLICIT,
7251      LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
7252
7253   if (tmp == error_mark_node)
7254     return;
7255   else if (tmp != NULL_TREE)
7256     {
7257       init = tmp;
7258       tmp = save_expr (tmp);
7259       if (building_stmt_tree ())
7260         {
7261           /* Initialize the declaration.  */
7262           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7263           finish_expr_stmt (tmp);
7264         }
7265       else
7266         DECL_INITIAL (decl) = tmp;
7267     }
7268   else
7269     {
7270       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7271       return;
7272     }
7273
7274   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7275     {
7276       expand_static_init (decl, DECL_INITIAL (decl));
7277       DECL_INITIAL (decl) = NULL_TREE;
7278     }
7279   return;
7280 }
7281
7282 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7283    mucking with forces it does not comprehend (i.e. initialization with a
7284    constructor).  If we are at global scope and won't go into COMMON, fill
7285    it in with a dummy CONSTRUCTOR to force the variable into .data;
7286    otherwise we can use error_mark_node.  */
7287
7288 static tree
7289 obscure_complex_init (decl, init)
7290      tree decl, init;
7291 {
7292   if (! flag_no_inline && TREE_STATIC (decl))
7293     {
7294       if (extract_init (decl, init))
7295         return NULL_TREE;
7296     }
7297
7298 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7299   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7300     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7301                                  NULL_TREE);
7302   else
7303 #endif
7304     DECL_INITIAL (decl) = error_mark_node;
7305
7306   return init;
7307 }
7308
7309 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7310    array until we finish parsing the initializer.  If that's the
7311    situation we're in, update DECL accordingly.  */
7312
7313 static void
7314 maybe_deduce_size_from_array_init (decl, init)
7315      tree decl;
7316      tree init;
7317 {
7318   tree type = TREE_TYPE (decl);
7319
7320   if (TREE_CODE (type) == ARRAY_TYPE
7321       && TYPE_DOMAIN (type) == NULL_TREE
7322       && TREE_CODE (decl) != TYPE_DECL)
7323     {
7324       int do_default
7325         = (TREE_STATIC (decl)
7326            /* Even if pedantic, an external linkage array
7327               may have incomplete type at first.  */
7328            ? pedantic && ! DECL_EXTERNAL (decl)
7329            : !DECL_EXTERNAL (decl));
7330       tree initializer = init ? init : DECL_INITIAL (decl);
7331       int failure = complete_array_type (type, initializer, do_default);
7332
7333       if (failure == 1)
7334         cp_error ("initializer fails to determine size of `%D'", decl);
7335
7336       if (failure == 2)
7337         {
7338           if (do_default)
7339             cp_error ("array size missing in `%D'", decl);
7340           /* If a `static' var's size isn't known, make it extern as
7341              well as static, so it does not get allocated.  If it's not
7342              `static', then don't mark it extern; finish_incomplete_decl
7343              will give it a default size and it will get allocated.  */
7344           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7345             DECL_EXTERNAL (decl) = 1;
7346         }
7347
7348       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7349           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7350                               integer_zero_node))
7351         cp_error ("zero-size array `%D'", decl);
7352
7353       layout_decl (decl, 0);
7354     }
7355 }
7356
7357 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7358    any appropriate error messages regarding the layout.  */
7359
7360 static void
7361 layout_var_decl (decl)
7362      tree decl;
7363 {
7364   tree type = TREE_TYPE (decl);
7365 #if 0
7366   tree ttype = target_type (type);
7367 #endif
7368
7369   /* If we haven't already layed out this declaration, do so now.
7370      Note that we must not call complete type for an external object
7371      because it's type might involve templates that we are not
7372      supposed to isntantiate yet.  (And it's perfectly legal to say
7373      `extern X x' for some incomplete type `X'.)  */
7374   if (!DECL_EXTERNAL (decl))
7375     complete_type (type);
7376   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7377     layout_decl (decl, 0);
7378
7379   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7380     {
7381       /* An automatic variable with an incomplete type: that is an error.
7382          Don't talk about array types here, since we took care of that
7383          message in grokdeclarator.  */
7384       cp_error ("storage size of `%D' isn't known", decl);
7385       TREE_TYPE (decl) = error_mark_node;
7386     }
7387 #if 0
7388   /* Keep this code around in case we later want to control debug info
7389      based on whether a type is "used".  (jason 1999-11-11) */
7390
7391   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7392     /* Let debugger know it should output info for this type.  */
7393     note_debug_info_needed (ttype);
7394
7395   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7396     note_debug_info_needed (DECL_CONTEXT (decl));
7397 #endif
7398
7399   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7400       && DECL_SIZE (decl) != NULL_TREE
7401       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7402     {
7403       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7404         constant_expression_warning (DECL_SIZE (decl));
7405       else
7406         cp_error ("storage size of `%D' isn't constant", decl);
7407     }
7408 }
7409
7410 /* If a local static variable is declared in an inline function, or if
7411    we have a weak definition, we must endeavor to create only one
7412    instance of the variable at link-time.  */
7413
7414 static void
7415 maybe_commonize_var (decl)
7416      tree decl;
7417 {
7418   /* Static data in a function with comdat linkage also has comdat
7419      linkage.  */
7420   if (TREE_STATIC (decl)
7421       /* Don't mess with __FUNCTION__.  */
7422       && ! DECL_ARTIFICIAL (decl)
7423       && current_function_decl
7424       && DECL_CONTEXT (decl) == current_function_decl
7425       && (DECL_THIS_INLINE (current_function_decl)
7426           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7427       && TREE_PUBLIC (current_function_decl))
7428     {
7429       /* Rather than try to get this right with inlining, we suppress
7430          inlining of such functions.  */
7431       current_function_cannot_inline
7432         = "function with static variable cannot be inline";
7433
7434       /* If flag_weak, we don't need to mess with this, as we can just
7435          make the function weak, and let it refer to its unique local
7436          copy.  This works because we don't allow the function to be
7437          inlined.  */
7438       if (! flag_weak)
7439         {
7440           if (DECL_INTERFACE_KNOWN (current_function_decl))
7441             {
7442               TREE_PUBLIC (decl) = 1;
7443               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7444             }
7445           else if (DECL_INITIAL (decl) == NULL_TREE
7446                    || DECL_INITIAL (decl) == error_mark_node)
7447             {
7448               TREE_PUBLIC (decl) = 1;
7449               DECL_COMMON (decl) = 1;
7450             }
7451           /* else we lose. We can only do this if we can use common,
7452              which we can't if it has been initialized.  */
7453
7454           if (TREE_PUBLIC (decl))
7455             DECL_ASSEMBLER_NAME (decl)
7456               = build_static_name (current_function_decl, DECL_NAME (decl));
7457           else
7458             {
7459               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7460               cp_warning_at ("  you can work around this by removing the initializer", decl);
7461             }
7462         }
7463     }
7464   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7465     /* Set it up again; we might have set DECL_INITIAL since the last
7466        time.  */
7467     comdat_linkage (decl);
7468 }
7469
7470 /* Issue an error message if DECL is an uninitialized const variable.  */
7471
7472 static void
7473 check_for_uninitialized_const_var (decl)
7474      tree decl;
7475 {
7476   tree type = TREE_TYPE (decl);
7477
7478   /* ``Unless explicitly declared extern, a const object does not have
7479      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7480      7.1.6 */
7481   if (TREE_CODE (decl) == VAR_DECL
7482       && TREE_CODE (type) != REFERENCE_TYPE
7483       && CP_TYPE_CONST_P (type)
7484       && !TYPE_NEEDS_CONSTRUCTING (type)
7485       && !DECL_INITIAL (decl))
7486     cp_error ("uninitialized const `%D'", decl);
7487 }
7488
7489 /* Verify INIT (the initializer for DECL), and record the
7490    initialization in DECL_INITIAL, if appropriate.  Returns a new
7491    value for INIT.  */
7492
7493 static tree
7494 check_initializer (decl, init)
7495      tree decl;
7496      tree init;
7497 {
7498   tree type;
7499
7500   if (TREE_CODE (decl) == FIELD_DECL)
7501     return init;
7502
7503   type = TREE_TYPE (decl);
7504
7505   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7506   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7507     init = NULL_TREE;
7508
7509   /* Check the initializer.  */
7510   if (init)
7511     {
7512       /* Things that are going to be initialized need to have complete
7513          type.  */
7514       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7515
7516       if (type == error_mark_node)
7517         /* We will have already complained.  */
7518         init = NULL_TREE;
7519       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7520         {
7521           cp_error ("variable-sized object `%D' may not be initialized", decl);
7522           init = NULL_TREE;
7523         }
7524       else if (TREE_CODE (type) == ARRAY_TYPE
7525                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7526         {
7527           cp_error ("elements of array `%#D' have incomplete type", decl);
7528           init = NULL_TREE;
7529         }
7530       else if (!COMPLETE_TYPE_P (type))
7531         {
7532           cp_error ("`%D' has incomplete type", decl);
7533           TREE_TYPE (decl) = error_mark_node;
7534           init = NULL_TREE;
7535         }
7536     }
7537
7538   if (TREE_CODE (decl) == CONST_DECL)
7539     {
7540       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7541
7542       DECL_INITIAL (decl) = init;
7543
7544       /* This will keep us from needing to worry about our obstacks.  */
7545       my_friendly_assert (init != NULL_TREE, 149);
7546       init = NULL_TREE;
7547     }
7548   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7549     {
7550       if (TREE_STATIC (decl))
7551         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7552       grok_reference_init (decl, type, init);
7553       init = NULL_TREE;
7554     }
7555   else if (init)
7556     {
7557       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7558         {
7559           if (TREE_CODE (type) == ARRAY_TYPE)
7560             init = digest_init (type, init, (tree *) 0);
7561           else if (TREE_CODE (init) == CONSTRUCTOR
7562                    && TREE_HAS_CONSTRUCTOR (init))
7563             {
7564               if (TYPE_NON_AGGREGATE_CLASS (type))
7565                 {
7566                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7567                             decl);
7568                   init = error_mark_node;
7569                 }
7570               else
7571                 goto dont_use_constructor;
7572             }
7573         }
7574       else
7575         {
7576         dont_use_constructor:
7577           if (TREE_CODE (init) != TREE_VEC)
7578             init = store_init_value (decl, init);
7579         }
7580
7581       if (init)
7582         /* We must hide the initializer so that expand_decl
7583            won't try to do something it does not understand.  */
7584         init = obscure_complex_init (decl, init);
7585     }
7586   else if (DECL_EXTERNAL (decl))
7587     ;
7588   else if (TYPE_P (type)
7589            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7590     {
7591       tree core_type = strip_array_types (type);
7592
7593       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7594         {
7595           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7596             cp_error ("structure `%D' with uninitialized const members", decl);
7597           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7598             cp_error ("structure `%D' with uninitialized reference members",
7599                       decl);
7600         }
7601
7602       check_for_uninitialized_const_var (decl);
7603
7604       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7605         init = obscure_complex_init (decl, NULL_TREE);
7606
7607     }
7608   else
7609     check_for_uninitialized_const_var (decl);
7610
7611   return init;
7612 }
7613
7614 /* If DECL is not a local variable, give it RTL.  */
7615
7616 static void
7617 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7618      tree decl;
7619      tree init;
7620      const char *asmspec;
7621 {
7622   int toplev;
7623   tree type;
7624
7625   type = TREE_TYPE (decl);
7626   toplev = toplevel_bindings_p ();
7627
7628   /* Handle non-variables up front.  */
7629   if (TREE_CODE (decl) != VAR_DECL)
7630     {
7631       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7632       return;
7633     }
7634
7635   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7636   if (asmspec)
7637     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7638
7639   if (DECL_VIRTUAL_P (decl))
7640     make_decl_rtl (decl, NULL_PTR, toplev);
7641   else if (TREE_READONLY (decl)
7642            && DECL_INITIAL (decl) != NULL_TREE
7643            && DECL_INITIAL (decl) != error_mark_node
7644            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7645     {
7646       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7647
7648       if (toplev && ! TREE_PUBLIC (decl))
7649         {
7650           /* If this is a static const, change its apparent linkage
7651              if it belongs to a #pragma interface.  */
7652           if (!interface_unknown)
7653             {
7654               TREE_PUBLIC (decl) = 1;
7655               DECL_EXTERNAL (decl) = interface_only;
7656             }
7657           make_decl_rtl (decl, asmspec, toplev);
7658         }
7659       else if (toplev)
7660         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7661     }
7662   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7663     {
7664       my_friendly_assert (TREE_STATIC (decl), 19990828);
7665
7666       if (init == NULL_TREE
7667 #ifdef DEFAULT_STATIC_DEFS
7668           /* If this code is dead, then users must
7669              explicitly declare static member variables
7670              outside the class def'n as well.  */
7671           && TYPE_NEEDS_CONSTRUCTING (type)
7672 #endif
7673           )
7674         {
7675           DECL_EXTERNAL (decl) = 1;
7676           make_decl_rtl (decl, asmspec, 1);
7677         }
7678       else
7679         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7680     }
7681   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7682            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7683     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7684 }
7685
7686 /* Create RTL for the local static variable DECL.  */
7687
7688 void
7689 make_rtl_for_local_static (decl)
7690      tree decl;
7691 {
7692   const char *asmspec = NULL;
7693
7694   /* If we inlined this variable, we could see it's declaration
7695      again.  */
7696   if (DECL_RTL (decl))
7697     return;
7698
7699   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7700     {
7701       /* The only way this situaton can occur is if the
7702          user specified a name for this DECL using the
7703          `attribute' syntax.  */
7704       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7705       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7706     }
7707
7708   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7709 }
7710
7711 /* The old ARM scoping rules injected variables declared in the
7712    initialization statement of a for-statement into the surrounding
7713    scope.  We support this usage, in order to be backward-compatible.
7714    DECL is a just-declared VAR_DECL; if necessary inject its
7715    declaration into the surrounding scope.  */
7716
7717 void
7718 maybe_inject_for_scope_var (decl)
7719      tree decl;
7720 {
7721   if (current_binding_level->is_for_scope)
7722     {
7723       struct binding_level *outer
7724         = current_binding_level->level_chain;
7725
7726       /* Check to see if the same name is already bound at the outer
7727          level, either because it was directly declared, or because a
7728          dead for-decl got preserved.  In either case, the code would
7729          not have been valid under the ARM scope rules, so clear
7730          is_for_scope for the current_binding_level.
7731
7732          Otherwise, we need to preserve the temp slot for decl to last
7733          into the outer binding level.  */
7734
7735       tree outer_binding
7736         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7737
7738       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7739           && (TREE_CODE (BINDING_VALUE (outer_binding))
7740               == VAR_DECL)
7741           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7742         {
7743           BINDING_VALUE (outer_binding)
7744             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7745           current_binding_level->is_for_scope = 0;
7746         }
7747       else if (DECL_IN_MEMORY_P (decl))
7748         preserve_temp_slots (DECL_RTL (decl));
7749     }
7750 }
7751
7752 /* Generate code to initialize DECL (a local variable).  */
7753
7754 void
7755 initialize_local_var (decl, init, flags)
7756      tree decl;
7757      tree init;
7758      int flags;
7759 {
7760   tree type = TREE_TYPE (decl);
7761
7762   /* If the type is bogus, don't bother initializing the variable.  */
7763   if (type == error_mark_node)
7764     return;
7765
7766   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7767     {
7768       /* If we used it already as memory, it must stay in memory.  */
7769       DECL_INITIAL (decl) = NULL_TREE;
7770       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7771     }
7772
7773   /* Local statics are handled differently from ordinary automatic
7774      variables.  */
7775   if (TREE_STATIC (decl))
7776     {
7777       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7778           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7779         expand_static_init (decl, init);
7780       return;
7781     }
7782
7783   if (DECL_SIZE (decl) && type != error_mark_node)
7784     {
7785       int already_used;
7786
7787       /* Compute and store the initial value.  */
7788       already_used = TREE_USED (decl) || TREE_USED (type);
7789
7790       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7791         {
7792           int saved_stmts_are_full_exprs_p;
7793
7794           emit_line_note (DECL_SOURCE_FILE (decl),
7795                           DECL_SOURCE_LINE (decl));
7796           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7797           stmts_are_full_exprs_p = 1;
7798           finish_expr_stmt (build_aggr_init (decl, init, flags));
7799           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7800         }
7801
7802       /* Set this to 0 so we can tell whether an aggregate which was
7803          initialized was ever used.  Don't do this if it has a
7804          destructor, so we don't complain about the 'resource
7805          allocation is initialization' idiom.  Now set
7806          attribute((unused)) on types so decls of that type will be
7807          marked used. (see TREE_USED, above.)  */
7808       if (TYPE_NEEDS_CONSTRUCTING (type)
7809           && ! already_used
7810           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7811           && DECL_NAME (decl))
7812         TREE_USED (decl) = 0;
7813       else if (already_used)
7814         TREE_USED (decl) = 1;
7815     }
7816 }
7817
7818 /* Generate code to destroy DECL (a local variable).  */
7819
7820 static void
7821 destroy_local_var (decl)
7822      tree decl;
7823 {
7824   tree type = TREE_TYPE (decl);
7825   tree cleanup;
7826
7827   /* Only variables get cleaned up.  */
7828   if (TREE_CODE (decl) != VAR_DECL)
7829     return;
7830
7831   /* And only things with destructors need cleaning up.  */
7832   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7833     return;
7834
7835   if (TREE_CODE (decl) == VAR_DECL &&
7836       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7837     /* We don't clean up things that aren't defined in this
7838        translation unit, or that need a static cleanup.  The latter
7839        are handled by finish_file.  */
7840     return;
7841
7842   /* Compute the cleanup.  */
7843   cleanup = maybe_build_cleanup (decl);
7844
7845   /* Record the cleanup required for this declaration.  */
7846   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7847       && cleanup)
7848     finish_decl_cleanup (decl, cleanup);
7849 }
7850
7851 /* Let the back-end know about DECL.  */
7852
7853 void
7854 emit_local_var (decl)
7855      tree decl;
7856 {
7857   /* Create RTL for this variable.  */
7858   if (DECL_RTL (decl))
7859     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7860        All other local variables are assigned RTL in this function.  */
7861     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
7862                         19990828);
7863   else
7864     {
7865       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7866         /* The user must have specified an assembler name for this
7867            variable.  Set that up now.  */
7868         rest_of_decl_compilation
7869           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
7870            /*top_level=*/0, /*at_end=*/0);
7871       else
7872         expand_decl (decl);
7873     }
7874
7875   /* Actually do the initialization.  */
7876   if (stmts_are_full_exprs_p)
7877     expand_start_target_temps ();
7878
7879   expand_decl_init (decl);
7880
7881   if (stmts_are_full_exprs_p)
7882     expand_end_target_temps ();
7883 }
7884
7885 /* Finish processing of a declaration;
7886    install its line number and initial value.
7887    If the length of an array type is not known before,
7888    it must be determined now, from the initial value, or it is an error.
7889
7890    INIT0 holds the value of an initializer that should be allowed to escape
7891    the normal rules.
7892
7893    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7894    if the (init) syntax was used.  */
7895
7896 void
7897 cp_finish_decl (decl, init, asmspec_tree, flags)
7898      tree decl, init;
7899      tree asmspec_tree;
7900      int flags;
7901 {
7902   register tree type;
7903   tree ttype = NULL_TREE;
7904   const char *asmspec = NULL;
7905   int was_readonly = 0;
7906
7907   if (! decl)
7908     {
7909       if (init)
7910         error ("assignment (not initialization) in declaration");
7911       return;
7912     }
7913
7914   /* If a name was specified, get the string.  */
7915   if (asmspec_tree)
7916       asmspec = TREE_STRING_POINTER (asmspec_tree);
7917
7918   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7919     {
7920       cp_error ("cannot initialize `%D' to namespace `%D'",
7921                 decl, init);
7922       init = NULL_TREE;
7923     }
7924
7925   if (current_class_type
7926       && CP_DECL_CONTEXT (decl) == current_class_type
7927       && TYPE_BEING_DEFINED (current_class_type)
7928       && (DECL_INITIAL (decl) || init))
7929     DECL_DEFINED_IN_CLASS_P (decl) = 1;
7930
7931   if (TREE_CODE (decl) == VAR_DECL
7932       && DECL_CONTEXT (decl)
7933       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7934       && DECL_CONTEXT (decl) != current_namespace
7935       && init)
7936     {
7937       /* Leave the namespace of the object. */
7938       pop_decl_namespace ();
7939     }
7940
7941   type = TREE_TYPE (decl);
7942
7943   if (type == error_mark_node)
7944     return;
7945
7946   /* Add this declaration to the statement-tree.  */
7947   if (building_stmt_tree () && at_function_scope_p ())
7948     add_decl_stmt (decl);
7949
7950   if (TYPE_HAS_MUTABLE_P (type))
7951     TREE_READONLY (decl) = 0;
7952
7953   if (processing_template_decl)
7954     {
7955       if (init && DECL_INITIAL (decl))
7956         DECL_INITIAL (decl) = init;
7957       goto finish_end0;
7958     }
7959
7960   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7961   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7962
7963   /* Take care of TYPE_DECLs up front.  */
7964   if (TREE_CODE (decl) == TYPE_DECL)
7965     {
7966       if (init && DECL_INITIAL (decl))
7967         {
7968           /* typedef foo = bar; store the type of bar as the type of foo.  */
7969           TREE_TYPE (decl) = type = TREE_TYPE (init);
7970           DECL_INITIAL (decl) = init = NULL_TREE;
7971         }
7972       if (type != error_mark_node
7973           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7974         {
7975           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7976             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7977           set_identifier_type_value (DECL_NAME (decl), type);
7978           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7979         }
7980       GNU_xref_decl (current_function_decl, decl);
7981
7982       /* If we have installed this as the canonical typedef for this
7983          type, and that type has not been defined yet, delay emitting
7984          the debug information for it, as we will emit it later.  */
7985       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7986           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
7987         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7988
7989       rest_of_decl_compilation (decl, NULL_PTR,
7990                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7991       goto finish_end;
7992     }
7993
7994   if (TREE_CODE (decl) != FUNCTION_DECL)
7995     ttype = target_type (type);
7996
7997   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7998       && TYPE_NEEDS_CONSTRUCTING (type))
7999     {
8000       /* Currently, GNU C++ puts constants in text space, making them
8001          impossible to initialize.  In the future, one would hope for
8002          an operating system which understood the difference between
8003          initialization and the running of a program.  */
8004       was_readonly = 1;
8005       TREE_READONLY (decl) = 0;
8006     }
8007
8008   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8009     {
8010       /* This must override the asm specifier which was placed by
8011          grokclassfn.  Lay this out fresh.  */
8012       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8013       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8014       make_decl_rtl (decl, asmspec, 0);
8015     }
8016
8017   /* Deduce size of array from initialization, if not already known.  */
8018   maybe_deduce_size_from_array_init (decl, init);
8019   init = check_initializer (decl, init);
8020
8021   GNU_xref_decl (current_function_decl, decl);
8022
8023   if (TREE_CODE (decl) == VAR_DECL)
8024     layout_var_decl (decl);
8025
8026   /* Output the assembler code and/or RTL code for variables and functions,
8027      unless the type is an undefined structure or union.
8028      If not, it will get done when the type is completed.  */
8029   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8030       || TREE_CODE (decl) == RESULT_DECL)
8031     {
8032       if (TREE_CODE (decl) == VAR_DECL)
8033         maybe_commonize_var (decl);
8034
8035       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8036
8037       if (TREE_CODE (type) == FUNCTION_TYPE
8038           || TREE_CODE (type) == METHOD_TYPE)
8039         abstract_virtuals_error (decl,
8040                                  strip_array_types (TREE_TYPE (type)));
8041       else
8042         abstract_virtuals_error (decl, strip_array_types (type));
8043
8044       if (TREE_CODE (decl) == FUNCTION_DECL)
8045         ;
8046       else if (DECL_EXTERNAL (decl)
8047                && ! (DECL_LANG_SPECIFIC (decl)
8048                      && DECL_NOT_REALLY_EXTERN (decl)))
8049         {
8050           if (init)
8051             DECL_INITIAL (decl) = init;
8052         }
8053       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8054         {
8055           /* This is a local declaration.  */
8056           if (doing_semantic_analysis_p ())
8057             maybe_inject_for_scope_var (decl);
8058           /* Initialize the local variable.  But, if we're building a
8059              statement-tree, we'll do the initialization when we
8060              expand the tree.  */
8061           if (processing_template_decl)
8062             {
8063               if (init || DECL_INITIAL (decl) == error_mark_node)
8064                 DECL_INITIAL (decl) = init;
8065             }
8066           else
8067             {
8068               /* If we're not building RTL, then we need to do so
8069                  now.  */
8070               if (!building_stmt_tree ())
8071                 emit_local_var (decl);
8072               /* Initialize the variable.  */
8073               initialize_local_var (decl, init, flags);
8074               /* Clean up the variable.  */
8075               destroy_local_var (decl);
8076             }
8077         }
8078       else if (TREE_STATIC (decl) && type != error_mark_node)
8079         {
8080           /* Cleanups for static variables are handled by `finish_file'.  */
8081           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8082               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8083             expand_static_init (decl, init);
8084         }
8085     finish_end0:
8086
8087       /* Undo call to `pushclass' that was done in `start_decl'
8088          due to initialization of qualified member variable.
8089          I.e., Foo::x = 10;  */
8090       {
8091         tree context = CP_DECL_CONTEXT (decl);
8092         if (context
8093             && TYPE_P (context)
8094             && (TREE_CODE (decl) == VAR_DECL
8095                 /* We also have a pushclass done that we need to undo here
8096                    if we're at top level and declare a method.  */
8097                 || TREE_CODE (decl) == FUNCTION_DECL)
8098             /* If size hasn't been set, we're still defining it,
8099                and therefore inside the class body; don't pop
8100                the binding level..  */
8101             && COMPLETE_TYPE_P (context)
8102             && context == current_class_type)
8103           pop_nested_class ();
8104       }
8105     }
8106
8107  finish_end:
8108
8109   if (was_readonly)
8110     TREE_READONLY (decl) = 1;
8111 }
8112
8113 /* This is here for a midend callback from c-common.c */
8114
8115 void
8116 finish_decl (decl, init, asmspec_tree)
8117      tree decl, init;
8118      tree asmspec_tree;
8119 {
8120   cp_finish_decl (decl, init, asmspec_tree, 0);
8121 }
8122
8123 /* Returns a declaration for a VAR_DECL as if:
8124
8125      extern "C" TYPE NAME;
8126
8127    had been seen.  Used to create compiler-generated global
8128    variables.  */
8129
8130 tree
8131 declare_global_var (name, type)
8132      tree name;
8133      tree type;
8134 {
8135   tree decl;
8136
8137   push_to_top_level ();
8138   decl = build_decl (VAR_DECL, name, type);
8139   TREE_PUBLIC (decl) = 1;
8140   DECL_EXTERNAL (decl) = 1;
8141   DECL_ARTIFICIAL (decl) = 1;
8142   pushdecl (decl);
8143   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8144   pop_from_top_level ();
8145
8146   return decl;
8147 }
8148
8149 /* Returns a pointer to the `atexit' function.  Note that if
8150    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8151    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8152
8153 static tree
8154 get_atexit_node ()
8155 {
8156   tree atexit_fndecl;
8157   tree arg_types;
8158   tree fn_type;
8159   tree fn_ptr_type;
8160   const char *name;
8161
8162   if (atexit_node)
8163     return atexit_node;
8164
8165   if (flag_use_cxa_atexit)
8166     {
8167       /* The declaration for `__cxa_atexit' is:
8168
8169            int __cxa_atexit (void (*)(void *), void *, void *)
8170
8171          We build up the argument types and then then function type
8172          itself.  */
8173
8174       /* First, build the pointer-to-function type for the first
8175          argument.  */
8176       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8177       fn_type = build_function_type (void_type_node, arg_types);
8178       fn_ptr_type = build_pointer_type (fn_type);
8179       /* Then, build the rest of the argument types.  */
8180       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8181       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8182       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8183       /* And the final __cxa_atexit type.  */
8184       fn_type = build_function_type (integer_type_node, arg_types);
8185       fn_ptr_type = build_pointer_type (fn_type);
8186       name = "__cxa_atexit";
8187     }
8188   else
8189     {
8190       /* The declaration for `atexit' is:
8191
8192            int atexit (void (*)());
8193
8194          We build up the argument types and then then function type
8195          itself.  */
8196       fn_type = build_function_type (void_type_node, void_list_node);
8197       fn_ptr_type = build_pointer_type (fn_type);
8198       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8199       /* Build the final atexit type.  */
8200       fn_type = build_function_type (integer_type_node, arg_types);
8201       name = "atexit";
8202     }
8203
8204   /* Now, build the function declaration.  */
8205   push_lang_context (lang_name_c);
8206   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8207   mark_used (atexit_fndecl);
8208   pop_lang_context ();
8209   atexit_node = default_conversion (atexit_fndecl);
8210
8211   return atexit_node;
8212 }
8213
8214 /* Returns the __dso_handle VAR_DECL.  */
8215
8216 static tree
8217 get_dso_handle_node ()
8218 {
8219   if (dso_handle_node)
8220     return dso_handle_node;
8221
8222   /* Declare the variable.  */
8223   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8224                                         ptr_type_node);
8225
8226   return dso_handle_node;
8227 }
8228
8229 /* Begin a new function with internal linkage whose job will be simply
8230    to destroy some particular variable.  */
8231
8232 static tree
8233 start_cleanup_fn ()
8234 {
8235   static int counter = 0;
8236   int old_interface_unknown = interface_unknown;
8237   char name[32];
8238   tree parmtypes;
8239   tree fntype;
8240   tree fndecl;
8241
8242   push_to_top_level ();
8243
8244   /* No need to mangle this.  */
8245   push_lang_context (lang_name_c);
8246
8247   interface_unknown = 1;
8248
8249   /* Build the parameter-types.  */
8250   parmtypes = void_list_node;
8251   /* Functions passed to __cxa_atexit take an additional parameter.
8252      We'll just ignore it.  After we implement the new calling
8253      convention for destructors, we can eliminate the use of
8254      additional cleanup functions entirely in the -fnew-abi case.  */
8255   if (flag_use_cxa_atexit)
8256     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8257   /* Build the function type itself.  */
8258   fntype = build_function_type (void_type_node, parmtypes);
8259   /* Build the name of the function.  */
8260   sprintf (name, "__tcf_%d", counter++);
8261   /* Build the function declaration.  */
8262   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8263   /* It's a function with internal linkage, generated by the
8264      compiler.  */
8265   TREE_PUBLIC (fndecl) = 0;
8266   DECL_ARTIFICIAL (fndecl) = 1;
8267   /* Build the parameter.  */
8268   if (flag_use_cxa_atexit)
8269     {
8270       tree parmdecl;
8271
8272       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8273       DECL_CONTEXT (parmdecl) = fndecl;
8274       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8275       TREE_USED (parmdecl) = 1;
8276       DECL_ARGUMENTS (fndecl) = parmdecl;
8277     }
8278
8279   pushdecl (fndecl);
8280   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8281   do_pushlevel ();
8282
8283   interface_unknown = old_interface_unknown;
8284
8285   pop_lang_context ();
8286
8287   return current_function_decl;
8288 }
8289
8290 /* Finish the cleanup function begun by start_cleanup_fn.  */
8291
8292 static void
8293 end_cleanup_fn ()
8294 {
8295   do_poplevel ();
8296
8297   expand_body (finish_function (0));
8298
8299   pop_from_top_level ();
8300 }
8301
8302 /* Generate code to handle the destruction of DECL, an object with
8303    static storage duration.  */
8304
8305 void
8306 register_dtor_fn (decl)
8307      tree decl;
8308 {
8309   tree cleanup;
8310   tree compound_stmt;
8311   tree args;
8312   tree fcall;
8313
8314   int saved_flag_access_control;
8315
8316   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8317     return;
8318
8319   /* Call build_cleanup before we enter the anonymous function so that
8320      any access checks will be done relative to the current scope,
8321      rather than the scope of the anonymous function.  */
8322   build_cleanup (decl);
8323
8324   /* Now start the function.  */
8325   cleanup = start_cleanup_fn ();
8326
8327   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8328      to the original function, rather than the anonymous one.  That
8329      will make the back-end think that nested functions are in use,
8330      which causes confusion.  */
8331   saved_flag_access_control = flag_access_control;
8332   flag_access_control = 0;
8333   fcall = build_cleanup (decl);
8334   flag_access_control = saved_flag_access_control;
8335
8336   /* Create the body of the anonymous function.  */
8337   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8338   finish_expr_stmt (fcall);
8339   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8340   end_cleanup_fn ();
8341
8342   /* Call atexit with the cleanup function.  */
8343   mark_addressable (cleanup);
8344   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8345   if (flag_use_cxa_atexit)
8346     {
8347       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8348       args = tree_cons (NULL_TREE, null_pointer_node, args);
8349       args = tree_cons (NULL_TREE, cleanup, args);
8350     }
8351   else
8352     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8353   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8354 }
8355
8356 void
8357 expand_static_init (decl, init)
8358      tree decl;
8359      tree init;
8360 {
8361   tree oldstatic = value_member (decl, static_aggregates);
8362
8363   if (oldstatic)
8364     {
8365       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8366         cp_error ("multiple initializations given for `%D'", decl);
8367     }
8368   else if (! toplevel_bindings_p ())
8369     {
8370       /* Emit code to perform this initialization but once.  */
8371       tree temp;
8372       tree if_stmt;
8373       tree then_clause;
8374       tree assignment;
8375       tree temp_init;
8376
8377       /* Emit code to perform this initialization but once.  This code
8378          looks like:
8379
8380            static int temp = 0;
8381            if (!temp) {
8382              // Do initialization.
8383              temp = 1;
8384              // Register variable for destruction at end of program.
8385            }
8386
8387          Note that the `temp' variable is only set to 1 *after* the
8388          initialization is complete.  This ensures that an exception,
8389          thrown during the construction, will cause the variable to
8390          reinitialized when we pass through this code again, as per:
8391
8392            [stmt.dcl]
8393
8394            If the initialization exits by throwing an exception, the
8395            initialization is not complete, so it will be tried again
8396            the next time control enters the declaration.
8397
8398          In theory, this process should be thread-safe, too; multiple
8399          threads should not be able to initialize the variable more
8400          than once.  We don't yet attempt to ensure thread-safety.  */
8401       temp = get_temp_name (integer_type_node, 1);
8402       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8403
8404       /* Begin the conditional initialization.  */
8405       if_stmt = begin_if_stmt ();
8406       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8407                                             integer_zero_node),
8408                            if_stmt);
8409       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8410
8411       /* Do the initialization itself.  */
8412       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8413           || (init && TREE_CODE (init) == TREE_LIST))
8414         assignment = build_aggr_init (decl, init, 0);
8415       else if (init)
8416         /* The initialization we're doing here is just a bitwise
8417            copy.  */
8418         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8419       else
8420         assignment = NULL_TREE;
8421
8422       /* Once the assignment is complete, set TEMP to 1.  Since the
8423          construction of the static object is complete at this point,
8424          we want to make sure TEMP is set to 1 even if a temporary
8425          constructed during the initialization throws an exception
8426          when it is destroyed.  So, we combine the initialization and
8427          the assignment to TEMP into a single expression, ensuring
8428          that when we call finish_expr_stmt the cleanups will not be
8429          run until after TEMP is set to 1.  */
8430       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8431       if (assignment)
8432         {
8433           assignment = tree_cons (NULL_TREE, assignment,
8434                                   build_tree_list (NULL_TREE,
8435                                                    temp_init));
8436           assignment = build_compound_expr (assignment);
8437         }
8438       else
8439         assignment = temp_init;
8440       finish_expr_stmt (assignment);
8441
8442       /* Use atexit to register a function for destroying this static
8443          variable.  */
8444       register_dtor_fn (decl);
8445
8446       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8447       finish_then_clause (if_stmt);
8448       finish_if_stmt ();
8449     }
8450   else
8451     static_aggregates = tree_cons (init, decl, static_aggregates);
8452 }
8453
8454 /* Finish the declaration of a catch-parameter.  */
8455
8456 tree
8457 start_handler_parms (declspecs, declarator)
8458      tree declspecs;
8459      tree declarator;
8460 {
8461   tree decl;
8462   if (declspecs)
8463     {
8464       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8465                              1, NULL_TREE);
8466       if (decl == NULL_TREE)
8467         error ("invalid catch parameter");
8468     }
8469   else
8470     decl = NULL_TREE;
8471
8472   return decl;
8473 }
8474
8475 \f
8476 /* Make TYPE a complete type based on INITIAL_VALUE.
8477    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8478    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8479
8480 int
8481 complete_array_type (type, initial_value, do_default)
8482      tree type, initial_value;
8483      int do_default;
8484 {
8485   register tree maxindex = NULL_TREE;
8486   int value = 0;
8487
8488   if (initial_value)
8489     {
8490       /* Note MAXINDEX  is really the maximum index,
8491          one less than the size.  */
8492       if (TREE_CODE (initial_value) == STRING_CST)
8493         {
8494           int eltsize
8495             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8496           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8497                                    / eltsize) - 1, 0);
8498         }
8499       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8500         {
8501           tree elts = CONSTRUCTOR_ELTS (initial_value);
8502
8503           maxindex = ssize_int (-1);
8504           for (; elts; elts = TREE_CHAIN (elts))
8505             {
8506               if (TREE_PURPOSE (elts))
8507                 maxindex = TREE_PURPOSE (elts);
8508               else
8509                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8510             }
8511           maxindex = copy_node (maxindex);
8512         }
8513       else
8514         {
8515           /* Make an error message unless that happened already.  */
8516           if (initial_value != error_mark_node)
8517             value = 1;
8518           else
8519             initial_value = NULL_TREE;
8520
8521           /* Prevent further error messages.  */
8522           maxindex = build_int_2 (0, 0);
8523         }
8524     }
8525
8526   if (!maxindex)
8527     {
8528       if (do_default)
8529         maxindex = build_int_2 (0, 0);
8530       value = 2;
8531     }
8532
8533   if (maxindex)
8534     {
8535       tree itype;
8536       tree domain;
8537
8538       domain = build_index_type (maxindex);
8539       TYPE_DOMAIN (type) = domain;
8540
8541       if (! TREE_TYPE (maxindex))
8542         TREE_TYPE (maxindex) = domain;
8543       if (initial_value)
8544         itype = TREE_TYPE (initial_value);
8545       else
8546         itype = NULL;
8547       if (itype && !TYPE_DOMAIN (itype))
8548         TYPE_DOMAIN (itype) = domain;
8549       /* The type of the main variant should never be used for arrays
8550          of different sizes.  It should only ever be completed with the
8551          size of the array.  */
8552       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8553         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8554     }
8555
8556   /* Lay out the type now that we can get the real answer.  */
8557
8558   layout_type (type);
8559
8560   return value;
8561 }
8562 \f
8563 /* Return zero if something is declared to be a member of type
8564    CTYPE when in the context of CUR_TYPE.  STRING is the error
8565    message to print in that case.  Otherwise, quietly return 1.  */
8566
8567 static int
8568 member_function_or_else (ctype, cur_type, flags)
8569      tree ctype, cur_type;
8570      enum overload_flags flags;
8571 {
8572   if (ctype && ctype != cur_type)
8573     {
8574       if (flags == DTOR_FLAG)
8575         error ("destructor for alien class `%s' cannot be a member",
8576                TYPE_NAME_STRING (ctype));
8577       else
8578         error ("constructor for alien class `%s' cannot be a member",
8579                TYPE_NAME_STRING (ctype));
8580       return 0;
8581     }
8582   return 1;
8583 }
8584 \f
8585 /* Subroutine of `grokdeclarator'.  */
8586
8587 /* Generate errors possibly applicable for a given set of specifiers.
8588    This is for ARM $7.1.2.  */
8589
8590 static void
8591 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8592      tree object;
8593      const char *type;
8594      int virtualp, quals, friendp, raises, inlinep;
8595 {
8596   if (virtualp)
8597     cp_error ("`%D' declared as a `virtual' %s", object, type);
8598   if (inlinep)
8599     cp_error ("`%D' declared as an `inline' %s", object, type);
8600   if (quals)
8601     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8602               object, type);
8603   if (friendp)
8604     cp_error_at ("`%D' declared as a friend", object);
8605   if (raises)
8606     cp_error_at ("`%D' declared with an exception specification", object);
8607 }
8608
8609 /* CTYPE is class type, or null if non-class.
8610    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8611    or METHOD_TYPE.
8612    DECLARATOR is the function's name.
8613    VIRTUALP is truthvalue of whether the function is virtual or not.
8614    FLAGS are to be passed through to `grokclassfn'.
8615    QUALS are qualifiers indicating whether the function is `const'
8616    or `volatile'.
8617    RAISES is a list of exceptions that this function can raise.
8618    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8619    not look, and -1 if we should not call `grokclassfn' at all.
8620
8621    Returns `NULL_TREE' if something goes wrong, after issuing
8622    applicable error messages.  */
8623
8624 static tree
8625 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8626             raises, check, friendp, publicp, inlinep, funcdef_flag,
8627             template_count, in_namespace)
8628      tree ctype, type;
8629      tree declarator;
8630      tree orig_declarator;
8631      int virtualp;
8632      enum overload_flags flags;
8633      tree quals, raises;
8634      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8635      tree in_namespace;
8636 {
8637   tree cname, decl;
8638   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8639   int has_default_arg = 0;
8640   tree t;
8641
8642   if (ctype)
8643     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8644       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8645   else
8646     cname = NULL_TREE;
8647
8648   if (raises)
8649     {
8650       type = build_exception_variant (type, raises);
8651     }
8652
8653   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8654   /* Propagate volatile out from type to decl. */
8655   if (TYPE_VOLATILE (type))
8656     TREE_THIS_VOLATILE (decl) = 1;
8657
8658   /* If this decl has namespace scope, set that up.  */
8659   if (in_namespace)
8660     set_decl_namespace (decl, in_namespace, friendp);
8661   else if (publicp && ! ctype)
8662     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8663
8664   /* `main' and builtins have implicit 'C' linkage.  */
8665   if ((MAIN_NAME_P (declarator)
8666        || (IDENTIFIER_LENGTH (declarator) > 10
8667            && IDENTIFIER_POINTER (declarator)[0] == '_'
8668            && IDENTIFIER_POINTER (declarator)[1] == '_'
8669            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8670       && current_lang_name == lang_name_cplusplus
8671       && ctype == NULL_TREE
8672       /* NULL_TREE means global namespace.  */
8673       && DECL_CONTEXT (decl) == NULL_TREE)
8674     DECL_LANGUAGE (decl) = lang_c;
8675
8676   /* Should probably propagate const out from type to decl I bet (mrs).  */
8677   if (staticp)
8678     {
8679       DECL_STATIC_FUNCTION_P (decl) = 1;
8680       DECL_CONTEXT (decl) = ctype;
8681     }
8682
8683   if (ctype)
8684     DECL_CONTEXT (decl) = ctype;
8685
8686   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8687     {
8688       if (processing_template_decl)
8689         error ("cannot declare `::main' to be a template");
8690       if (inlinep)
8691         error ("cannot declare `::main' to be inline");
8692       else if (! publicp)
8693         error ("cannot declare `::main' to be static");
8694       inlinep = 0;
8695       publicp = 1;
8696     }
8697
8698   /* Members of anonymous types and local classes have no linkage; make
8699      them internal.  */
8700   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8701                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8702     publicp = 0;
8703
8704   if (publicp)
8705     {
8706       /* [basic.link]: A name with no linkage (notably, the name of a class
8707          or enumeration declared in a local scope) shall not be used to
8708          declare an entity with linkage.
8709
8710          Only check this for public decls for now.  */
8711       t = no_linkage_check (TREE_TYPE (decl));
8712       if (t)
8713         {
8714           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8715             {
8716               if (DECL_EXTERN_C_P (decl))
8717                 /* Allow this; it's pretty common in C.  */;
8718               else
8719                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8720                             decl);
8721             }
8722           else
8723             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8724                         decl, t);
8725         }
8726     }
8727
8728   TREE_PUBLIC (decl) = publicp;
8729   if (! publicp)
8730     {
8731       DECL_INTERFACE_KNOWN (decl) = 1;
8732       DECL_NOT_REALLY_EXTERN (decl) = 1;
8733     }
8734
8735   if (inlinep)
8736     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8737
8738   DECL_EXTERNAL (decl) = 1;
8739   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8740     {
8741       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8742                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8743       quals = NULL_TREE;
8744     }
8745
8746   if (DECL_OVERLOADED_OPERATOR_P (decl))
8747     grok_op_properties (decl, virtualp, check < 0);
8748
8749   if (ctype && decl_function_context (decl))
8750     DECL_NO_STATIC_CHAIN (decl) = 1;
8751
8752   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8753     if (TREE_PURPOSE (t)
8754         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8755       {
8756         has_default_arg = 1;
8757         break;
8758       }
8759
8760   if (friendp
8761       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8762     {
8763       if (funcdef_flag)
8764         cp_error
8765           ("defining explicit specialization `%D' in friend declaration",
8766            orig_declarator);
8767       else
8768         {
8769           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8770             {
8771               /* Something like `template <class T> friend void f<T>()'.  */
8772               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8773                         orig_declarator);
8774               return NULL_TREE;
8775             }
8776
8777
8778           /* A friend declaration of the form friend void f<>().  Record
8779              the information in the TEMPLATE_ID_EXPR.  */
8780           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8781           DECL_TEMPLATE_INFO (decl)
8782             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8783                          TREE_OPERAND (orig_declarator, 1),
8784                          NULL_TREE);
8785
8786           if (has_default_arg)
8787             {
8788               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8789                         decl);
8790               return NULL_TREE;
8791             }
8792
8793           if (inlinep)
8794             {
8795               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8796                         decl);
8797               return NULL_TREE;
8798             }
8799         }
8800     }
8801
8802   if (has_default_arg)
8803     add_defarg_fn (decl);
8804
8805   /* Plain overloading: will not be grok'd by grokclassfn.  */
8806   if (! ctype && ! processing_template_decl
8807       && !DECL_EXTERN_C_P (decl)
8808       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8809     set_mangled_name_for_decl (decl);
8810
8811   if (funcdef_flag)
8812     /* Make the init_value nonzero so pushdecl knows this is not
8813        tentative.  error_mark_node is replaced later with the BLOCK.  */
8814     DECL_INITIAL (decl) = error_mark_node;
8815
8816   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8817     TREE_NOTHROW (decl) = 1;
8818
8819   /* Caller will do the rest of this.  */
8820   if (check < 0)
8821     return decl;
8822
8823   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8824     DECL_CONSTRUCTOR_P (decl) = 1;
8825
8826   /* Function gets the ugly name, field gets the nice one.  This call
8827      may change the type of the function (because of default
8828      parameters)!  */
8829   if (ctype != NULL_TREE)
8830     grokclassfn (ctype, decl, flags, quals);
8831
8832   decl = check_explicit_specialization (orig_declarator, decl,
8833                                         template_count,
8834                                         2 * (funcdef_flag != 0) +
8835                                         4 * (friendp != 0));
8836   if (decl == error_mark_node)
8837     return NULL_TREE;
8838
8839   if (ctype != NULL_TREE
8840       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8841       && check)
8842     {
8843       tree old_decl;
8844
8845       old_decl = check_classfn (ctype, decl);
8846
8847       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8848         /* Because grokfndecl is always supposed to return a
8849            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8850            here.  We depend on our callers to figure out that its
8851            really a template that's being returned.  */
8852         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8853
8854       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8855           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8856         {
8857           /* Remove the `this' parm added by grokclassfn.
8858              XXX Isn't this done in start_function, too?  */
8859           revert_static_member_fn (decl);
8860           last_function_parms = TREE_CHAIN (last_function_parms);
8861         }
8862       if (old_decl && DECL_ARTIFICIAL (old_decl))
8863         cp_error ("definition of implicitly-declared `%D'", old_decl);
8864
8865       if (old_decl)
8866         {
8867           /* Since we've smashed OLD_DECL to its
8868              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8869           if (TREE_CODE (decl) == TEMPLATE_DECL)
8870             decl = DECL_TEMPLATE_RESULT (decl);
8871
8872           /* Attempt to merge the declarations.  This can fail, in
8873              the case of some illegal specialization declarations.  */
8874           if (!duplicate_decls (decl, old_decl))
8875             cp_error ("no `%#D' member function declared in class `%T'",
8876                       decl, ctype);
8877           return old_decl;
8878         }
8879     }
8880
8881   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8882     return NULL_TREE;
8883
8884   if (ctype == NULL_TREE || check)
8885     return decl;
8886
8887   if (virtualp)
8888     {
8889       DECL_VIRTUAL_P (decl) = 1;
8890       if (DECL_VINDEX (decl) == NULL_TREE)
8891         DECL_VINDEX (decl) = error_mark_node;
8892       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8893     }
8894
8895   return decl;
8896 }
8897
8898 static tree
8899 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8900      tree type;
8901      tree declarator;
8902      RID_BIT_TYPE *specbits_in;
8903      int initialized;
8904      int constp;
8905      tree in_namespace;
8906 {
8907   tree decl;
8908   RID_BIT_TYPE specbits;
8909
8910   specbits = *specbits_in;
8911
8912   if (TREE_CODE (type) == OFFSET_TYPE)
8913     {
8914       /* If you declare a static member so that it
8915          can be initialized, the code will reach here.  */
8916       tree basetype = TYPE_OFFSET_BASETYPE (type);
8917       type = TREE_TYPE (type);
8918       decl = build_lang_decl (VAR_DECL, declarator, type);
8919       DECL_CONTEXT (decl) = basetype;
8920       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8921     }
8922   else
8923     {
8924       tree context;
8925
8926       if (in_namespace)
8927         context = in_namespace;
8928       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8929         context = current_namespace;
8930       else
8931         context = NULL_TREE;
8932
8933       if (processing_template_decl && context)
8934         /* For global variables, declared in a template, we need the
8935            full lang_decl.  */
8936         decl = build_lang_decl (VAR_DECL, declarator, type);
8937       else
8938         decl = build_decl (VAR_DECL, declarator, type);
8939
8940       if (context)
8941         set_decl_namespace (decl, context, 0);
8942
8943       context = DECL_CONTEXT (decl);
8944       if (declarator && context && current_lang_name != lang_name_c)
8945         DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8946     }
8947
8948   if (in_namespace)
8949     set_decl_namespace (decl, in_namespace, 0);
8950
8951   if (RIDBIT_SETP (RID_EXTERN, specbits))
8952     {
8953       DECL_THIS_EXTERN (decl) = 1;
8954       DECL_EXTERNAL (decl) = !initialized;
8955     }
8956
8957   /* In class context, static means one per class,
8958      public access, and static storage.  */
8959   if (DECL_CLASS_SCOPE_P (decl))
8960     {
8961       TREE_PUBLIC (decl) = 1;
8962       TREE_STATIC (decl) = 1;
8963       DECL_EXTERNAL (decl) = 0;
8964     }
8965   /* At top level, either `static' or no s.c. makes a definition
8966      (perhaps tentative), and absence of `static' makes it public.  */
8967   else if (toplevel_bindings_p ())
8968     {
8969       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8970                             && (DECL_THIS_EXTERN (decl) || ! constp));
8971       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8972     }
8973   /* Not at top level, only `static' makes a static definition.  */
8974   else
8975     {
8976       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8977       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8978     }
8979
8980   if (TREE_PUBLIC (decl))
8981     {
8982       /* [basic.link]: A name with no linkage (notably, the name of a class
8983          or enumeration declared in a local scope) shall not be used to
8984          declare an entity with linkage.
8985
8986          Only check this for public decls for now.  */
8987       tree t = no_linkage_check (TREE_TYPE (decl));
8988       if (t)
8989         {
8990           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8991             /* Ignore for now; `enum { foo } e' is pretty common.  */;
8992           else
8993             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8994                         decl, t);
8995         }
8996     }
8997
8998   return decl;
8999 }
9000
9001 /* Create and return a canonical pointer to member function type, for
9002    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9003
9004 tree
9005 build_ptrmemfunc_type (type)
9006      tree type;
9007 {
9008   tree fields[4];
9009   tree t;
9010   tree u;
9011   tree unqualified_variant = NULL_TREE;
9012
9013   /* If a canonical type already exists for this type, use it.  We use
9014      this method instead of type_hash_canon, because it only does a
9015      simple equality check on the list of field members.  */
9016
9017   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9018     return t;
9019
9020   /* Make sure that we always have the unqualified pointer-to-member
9021      type first.  */
9022   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9023     unqualified_variant
9024       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9025
9026   t = make_aggr_type (RECORD_TYPE);
9027   /* Let the front-end know this is a pointer to member function...  */
9028   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9029   /* ... and not really an aggregate.  */
9030   SET_IS_AGGR_TYPE (t, 0);
9031
9032   if (!flag_new_abi)
9033     {
9034       u = make_aggr_type (UNION_TYPE);
9035       SET_IS_AGGR_TYPE (u, 0);
9036       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9037       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9038                               delta_type_node);
9039       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9040       TYPE_NAME (u) = NULL_TREE;
9041
9042       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9043                               delta_type_node);
9044       fields[1] = build_decl (FIELD_DECL, index_identifier,
9045                               delta_type_node);
9046       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9047       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9048     }
9049   else
9050     {
9051       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9052       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9053                               delta_type_node);
9054       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9055     }
9056
9057   /* Zap out the name so that the back-end will give us the debugging
9058      information for this anonymous RECORD_TYPE.  */
9059   TYPE_NAME (t) = NULL_TREE;
9060
9061   /* If this is not the unqualified form of this pointer-to-member
9062      type, set the TYPE_MAIN_VARIANT for this type to be the
9063      unqualified type.  Since they are actually RECORD_TYPEs that are
9064      not variants of each other, we must do this manually.  */
9065   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9066     {
9067       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9068       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9069       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9070       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9071     }
9072
9073   /* Cache this pointer-to-member type so that we can find it again
9074      later.  */
9075   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9076
9077   /* Seems to be wanted.  */
9078   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9079
9080   return t;
9081 }
9082
9083 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9084    Check to see that the definition is valid.  Issue appropriate error
9085    messages.  Return 1 if the definition is particularly bad, or 0
9086    otherwise.  */
9087
9088 int
9089 check_static_variable_definition (decl, type)
9090      tree decl;
9091      tree type;
9092 {
9093   /* Motion 10 at San Diego: If a static const integral data member is
9094      initialized with an integral constant expression, the initializer
9095      may appear either in the declaration (within the class), or in
9096      the definition, but not both.  If it appears in the class, the
9097      member is a member constant.  The file-scope definition is always
9098      required.  */
9099   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9100     {
9101       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9102                 type);
9103       /* If we just return the declaration, crashes will sometimes
9104          occur.  We therefore return void_type_node, as if this was a
9105          friend declaration, to cause callers to completely ignore
9106          this declaration.  */
9107       return 1;
9108     }
9109   else if (!CP_TYPE_CONST_P (type))
9110     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9111               decl);
9112   else if (pedantic && !INTEGRAL_TYPE_P (type))
9113     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9114
9115   return 0;
9116 }
9117
9118 /* Given the SIZE (i.e., number of elements) in an array, compute an
9119    appropriate index type for the array.  If non-NULL, NAME is the
9120    name of the thing being declared.  */
9121
9122 tree
9123 compute_array_index_type (name, size)
9124      tree name;
9125      tree size;
9126 {
9127   tree itype;
9128
9129   /* The size might be the result of a cast. */
9130   STRIP_TYPE_NOPS (size);
9131
9132   /* It might be a const variable or enumeration constant.  */
9133   size = decl_constant_value (size);
9134
9135   /* If this involves a template parameter, it will be a constant at
9136      instantiation time, but we don't know what the value is yet.
9137      Even if no template parameters are involved, we may an expression
9138      that is not a constant; we don't even simplify `1 + 2' when
9139      processing a template.  */
9140   if (processing_template_decl)
9141     {
9142       /* Resolve a qualified reference to an enumerator or static
9143          const data member of ours.  */
9144       if (TREE_CODE (size) == SCOPE_REF
9145           && TREE_OPERAND (size, 0) == current_class_type)
9146         {
9147           tree t = lookup_field (current_class_type,
9148                                  TREE_OPERAND (size, 1), 0, 0);
9149           if (t)
9150             size = t;
9151         }
9152
9153       return build_index_type (build_min (MINUS_EXPR, sizetype,
9154                                           size, integer_one_node));
9155     }
9156
9157   /* The array bound must be an integer type.  */
9158   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9159       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9160       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9161     {
9162       if (name)
9163         cp_error ("size of array `%D' has non-integer type", name);
9164       else
9165         cp_error ("size of array has non-integer type");
9166       size = integer_one_node;
9167     }
9168
9169   /* Normally, the array-bound will be a constant.  */
9170   if (TREE_CONSTANT (size))
9171     {
9172       /* Check to see if the array bound overflowed.  Make that an
9173          error, no matter how generous we're being.  */
9174       int old_flag_pedantic_errors = flag_pedantic_errors;
9175       int old_pedantic = pedantic;
9176       pedantic = flag_pedantic_errors = 1;
9177       constant_expression_warning (size);
9178       pedantic = old_pedantic;
9179       flag_pedantic_errors = old_flag_pedantic_errors;
9180
9181       /* An array must have a positive number of elements.  */
9182       if (INT_CST_LT (size, integer_zero_node))
9183         {
9184           if (name)
9185             cp_error ("size of array `%D' is negative", name);
9186           else
9187             cp_error ("size of array is negative");
9188           size = integer_one_node;
9189         }
9190       /* Except that an extension we allow zero-sized arrays.  We
9191          always allow them in system headers because glibc uses
9192          them.  */
9193       else if (integer_zerop (size) && pedantic && !in_system_header)
9194         {
9195           if (name)
9196             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9197           else
9198             cp_pedwarn ("ISO C++ forbids zero-size array");
9199         }
9200     }
9201
9202   /* Compute the index of the largest element in the array.  It is
9203      one less than the number of elements in the array.  */
9204   itype
9205     = fold (build_binary_op (MINUS_EXPR,
9206                              cp_convert (ssizetype, size),
9207                              cp_convert (ssizetype,
9208                                          integer_one_node)));
9209
9210   /* Check for variable-sized arrays.  We allow such things as an
9211      extension, even though they are not allowed in ANSI/ISO C++.  */
9212   if (!TREE_CONSTANT (itype))
9213     {
9214       if (pedantic)
9215         {
9216           if (name)
9217             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9218                         name);
9219           else
9220             cp_pedwarn ("ISO C++ forbids variable-size array");
9221         }
9222
9223       /* Create a variable-sized array index type.  */
9224       itype = variable_size (itype);
9225     }
9226   /* Make sure that there was no overflow when creating to a signed
9227      index type.  (For example, on a 32-bit machine, an array with
9228      size 2^32 - 1 is too big.)  */
9229   else if (TREE_OVERFLOW (itype))
9230     {
9231       error ("overflow in array dimension");
9232       TREE_OVERFLOW (itype) = 0;
9233     }
9234
9235   /* Create and return the appropriate index type.  */
9236   return build_index_type (itype);
9237 }
9238
9239 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9240    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9241    with this type.  */
9242
9243 static tree
9244 create_array_type_for_decl (name, type, size)
9245      tree name;
9246      tree type;
9247      tree size;
9248 {
9249   tree itype = NULL_TREE;
9250   const char* error_msg;
9251
9252   /* If things have already gone awry, bail now.  */
9253   if (type == error_mark_node || size == error_mark_node)
9254     return error_mark_node;
9255
9256   /* Assume that everything will go OK.  */
9257   error_msg = NULL;
9258
9259   /* There are some types which cannot be array elements.  */
9260   switch (TREE_CODE (type))
9261     {
9262     case VOID_TYPE:
9263       error_msg = "array of void";
9264       break;
9265
9266     case FUNCTION_TYPE:
9267       error_msg = "array of functions";
9268       break;
9269
9270     case REFERENCE_TYPE:
9271       error_msg = "array of references";
9272       break;
9273
9274     case OFFSET_TYPE:
9275       error_msg = "array of data members";
9276       break;
9277
9278     case METHOD_TYPE:
9279       error_msg = "array of function members";
9280       break;
9281
9282     default:
9283       break;
9284     }
9285
9286   /* If something went wrong, issue an error-message and return.  */
9287   if (error_msg)
9288     {
9289       if (name)
9290         cp_error ("declaration of `%D' as %s", name, error_msg);
9291       else
9292         cp_error ("creating %s", error_msg);
9293
9294       return error_mark_node;
9295     }
9296
9297   /* [dcl.array]
9298
9299      The constant expressions that specify the bounds of the arrays
9300      can be omitted only for the first member of the sequence.  */
9301   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9302     {
9303       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9304                 name);
9305
9306       return error_mark_node;
9307     }
9308
9309   /* Figure out the index type for the array.  */
9310   if (size)
9311     itype = compute_array_index_type (name, size);
9312
9313   return build_cplus_array_type (type, itype);
9314 }
9315
9316 /* Check that it's OK to declare a function with the indicated TYPE.
9317    SFK indicates the kind of special function (if any) that this
9318    function is.  CTYPE is the class of which this function is a
9319    member.  OPTYPE is the type given in a conversion operator
9320    declaration.  Returns the actual return type of the function; that
9321    may be different than TYPE if an error occurs, or for certain
9322    special functions.  */
9323
9324 static tree
9325 check_special_function_return_type (sfk, type, ctype, optype)
9326      special_function_kind sfk;
9327      tree type;
9328      tree ctype;
9329      tree optype;
9330 {
9331   switch (sfk)
9332     {
9333     case sfk_constructor:
9334       if (type)
9335         cp_error ("return type specification for constructor invalid");
9336
9337       /* In the old ABI, we return `this'; in the new ABI we don't
9338          bother.  */
9339       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9340       break;
9341
9342     case sfk_destructor:
9343       if (type)
9344         cp_error ("return type specification for destructor invalid");
9345       type = void_type_node;
9346       break;
9347
9348     case sfk_conversion:
9349       if (type && !same_type_p (type, optype))
9350         cp_error ("operator `%T' declared to return `%T'", optype, type);
9351       else if (type)
9352         cp_pedwarn ("return type specified for `operator %T'",  optype);
9353       type = optype;
9354       break;
9355
9356     default:
9357       my_friendly_abort (20000408);
9358       break;
9359     }
9360
9361   return type;
9362 }
9363
9364 /* Given declspecs and a declarator,
9365    determine the name and type of the object declared
9366    and construct a ..._DECL node for it.
9367    (In one case we can return a ..._TYPE node instead.
9368     For invalid input we sometimes return 0.)
9369
9370    DECLSPECS is a chain of tree_list nodes whose value fields
9371     are the storage classes and type specifiers.
9372
9373    DECL_CONTEXT says which syntactic context this declaration is in:
9374      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9375      FUNCDEF for a function definition.  Like NORMAL but a few different
9376       error messages in each case.  Return value may be zero meaning
9377       this definition is too screwy to try to parse.
9378      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9379       handle member functions (which have FIELD context).
9380       Return value may be zero meaning this definition is too screwy to
9381       try to parse.
9382      PARM for a parameter declaration (either within a function prototype
9383       or before a function body).  Make a PARM_DECL, or return void_type_node.
9384      CATCHPARM for a parameter declaration before a catch clause.
9385      TYPENAME if for a typename (in a cast or sizeof).
9386       Don't make a DECL node; just return the ..._TYPE node.
9387      FIELD for a struct or union field; make a FIELD_DECL.
9388      BITFIELD for a field with specified width.
9389    INITIALIZED is 1 if the decl has an initializer.
9390
9391    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9392    normal attributes in TREE_PURPOSE, or NULL_TREE.
9393
9394    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9395    It may also be so in the PARM case, for a prototype where the
9396    argument type is specified but not the name.
9397
9398    This function is where the complicated C meanings of `static'
9399    and `extern' are interpreted.
9400
9401    For C++, if there is any monkey business to do, the function which
9402    calls this one must do it, i.e., prepending instance variables,
9403    renaming overloaded function names, etc.
9404
9405    Note that for this C++, it is an error to define a method within a class
9406    which does not belong to that class.
9407
9408    Except in the case where SCOPE_REFs are implicitly known (such as
9409    methods within a class being redundantly qualified),
9410    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9411    (class_name::decl_name).  The caller must also deal with this.
9412
9413    If a constructor or destructor is seen, and the context is FIELD,
9414    then the type gains the attribute TREE_HAS_x.  If such a declaration
9415    is erroneous, NULL_TREE is returned.
9416
9417    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9418    function, these are the qualifiers to give to the `this' pointer. We
9419    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9420
9421    May return void_type_node if the declarator turned out to be a friend.
9422    See grokfield for details.  */
9423
9424 tree
9425 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9426      tree declspecs;
9427      tree declarator;
9428      enum decl_context decl_context;
9429      int initialized;
9430      tree attrlist;
9431 {
9432   RID_BIT_TYPE specbits;
9433   int nclasses = 0;
9434   tree spec;
9435   tree type = NULL_TREE;
9436   int longlong = 0;
9437   int constp;
9438   int restrictp;
9439   int volatilep;
9440   int type_quals;
9441   int virtualp, explicitp, friendp, inlinep, staticp;
9442   int explicit_int = 0;
9443   int explicit_char = 0;
9444   int defaulted_int = 0;
9445   tree typedef_decl = NULL_TREE;
9446   const char *name;
9447   tree typedef_type = NULL_TREE;
9448   int funcdef_flag = 0;
9449   enum tree_code innermost_code = ERROR_MARK;
9450   int bitfield = 0;
9451 #if 0
9452   /* See the code below that used this.  */
9453   tree decl_machine_attr = NULL_TREE;
9454 #endif
9455   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9456      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9457   tree init = NULL_TREE;
9458
9459   /* Keep track of what sort of function is being processed
9460      so that we can warn about default return values, or explicit
9461      return values which do not match prescribed defaults.  */
9462   special_function_kind sfk = sfk_none;
9463
9464   tree dname = NULL_TREE;
9465   tree ctype = current_class_type;
9466   tree ctor_return_type = NULL_TREE;
9467   enum overload_flags flags = NO_SPECIAL;
9468   tree quals = NULL_TREE;
9469   tree raises = NULL_TREE;
9470   int template_count = 0;
9471   tree in_namespace = NULL_TREE;
9472   tree inner_attrs;
9473   int ignore_attrs;
9474
9475   RIDBIT_RESET_ALL (specbits);
9476   if (decl_context == FUNCDEF)
9477     funcdef_flag = 1, decl_context = NORMAL;
9478   else if (decl_context == MEMFUNCDEF)
9479     funcdef_flag = -1, decl_context = FIELD;
9480   else if (decl_context == BITFIELD)
9481     bitfield = 1, decl_context = FIELD;
9482
9483   /* Look inside a declarator for the name being declared
9484      and get it as a string, for an error message.  */
9485   {
9486     tree *next = &declarator;
9487     register tree decl;
9488     name = NULL;
9489
9490     while (next && *next)
9491       {
9492         decl = *next;
9493         switch (TREE_CODE (decl))
9494           {
9495           case TREE_LIST:
9496             /* For attributes.  */
9497             next = &TREE_VALUE (decl);
9498             break;
9499
9500           case COND_EXPR:
9501             ctype = NULL_TREE;
9502             next = &TREE_OPERAND (decl, 0);
9503             break;
9504
9505           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9506             {
9507               tree name = TREE_OPERAND (decl, 0);
9508               tree rename = NULL_TREE;
9509
9510               my_friendly_assert (flags == NO_SPECIAL, 152);
9511               flags = DTOR_FLAG;
9512               sfk = sfk_destructor;
9513               if (TREE_CODE (name) == TYPE_DECL)
9514                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9515               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9516               if (ctype == NULL_TREE)
9517                 {
9518                   if (current_class_type == NULL_TREE)
9519                     {
9520                       error ("destructors must be member functions");
9521                       flags = NO_SPECIAL;
9522                     }
9523                   else
9524                     {
9525                       tree t = constructor_name (current_class_name);
9526                       if (t != name)
9527                         rename = t;
9528                     }
9529                 }
9530               else
9531                 {
9532                   tree t = constructor_name (ctype);
9533                   if (t != name)
9534                     rename = t;
9535                 }
9536
9537               if (rename)
9538                 {
9539                   cp_error ("destructor `%T' must match class name `%T'",
9540                             name, rename);
9541                   TREE_OPERAND (decl, 0) = rename;
9542                 }
9543               next = &name;
9544             }
9545             break;
9546
9547           case ADDR_EXPR:       /* C++ reference declaration */
9548             /* Fall through. */
9549           case ARRAY_REF:
9550           case INDIRECT_REF:
9551             ctype = NULL_TREE;
9552             innermost_code = TREE_CODE (decl);
9553             next = &TREE_OPERAND (decl, 0);
9554             break;
9555
9556           case CALL_EXPR:
9557             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9558               {
9559                 /* This is actually a variable declaration using
9560                    constructor syntax.  We need to call start_decl and
9561                    cp_finish_decl so we can get the variable
9562                    initialized...  */
9563
9564                 tree attributes, prefix_attributes;
9565
9566                 *next = TREE_OPERAND (decl, 0);
9567                 init = CALL_DECLARATOR_PARMS (decl);
9568
9569                 if (attrlist)
9570                   {
9571                     attributes = TREE_PURPOSE (attrlist);
9572                     prefix_attributes = TREE_VALUE (attrlist);
9573                   }
9574                 else
9575                   {
9576                     attributes = NULL_TREE;
9577                     prefix_attributes = NULL_TREE;
9578                   }
9579
9580                 decl = start_decl (declarator, declspecs, 1,
9581                                    attributes, prefix_attributes);
9582                 decl_type_access_control (decl);
9583                 if (decl)
9584                   {
9585                     /* Look for __unused__ attribute */
9586                     if (TREE_USED (TREE_TYPE (decl)))
9587                       TREE_USED (decl) = 1;
9588                     finish_decl (decl, init, NULL_TREE);
9589                   }
9590                 else
9591                   cp_error ("invalid declarator");
9592                 return 0;
9593               }
9594             innermost_code = TREE_CODE (decl);
9595             if (decl_context == FIELD && ctype == NULL_TREE)
9596               ctype = current_class_type;
9597             if (ctype
9598                 && TREE_OPERAND (decl, 0)
9599                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9600                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9601                          == constructor_name_full (ctype))
9602                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9603                             == constructor_name (ctype)))))
9604               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9605             next = &TREE_OPERAND (decl, 0);
9606             decl = *next;
9607             if (ctype != NULL_TREE
9608                 && decl != NULL_TREE && flags != DTOR_FLAG
9609                 && decl == constructor_name (ctype))
9610               {
9611                 sfk = sfk_constructor;
9612                 ctor_return_type = ctype;
9613               }
9614             ctype = NULL_TREE;
9615             break;
9616
9617           case TEMPLATE_ID_EXPR:
9618               {
9619                 tree fns = TREE_OPERAND (decl, 0);
9620
9621                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9622                   fns = TREE_OPERAND (fns, 0);
9623
9624                 dname = fns;
9625                 if (TREE_CODE (dname) == COMPONENT_REF)
9626                   dname = TREE_OPERAND (dname, 1);
9627                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9628                   {
9629                     my_friendly_assert (is_overloaded_fn (dname),
9630                                         19990331);
9631                     dname = DECL_NAME (get_first_fn (dname));
9632                   }
9633               }
9634           /* Fall through. */
9635
9636           case IDENTIFIER_NODE:
9637             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9638               dname = decl;
9639
9640             next = 0;
9641
9642             if (is_rid (dname))
9643               {
9644                 cp_error ("declarator-id missing; using reserved word `%D'",
9645                           dname);
9646                 name = IDENTIFIER_POINTER (dname);
9647               }
9648             else if (!IDENTIFIER_OPNAME_P (dname))
9649               name = IDENTIFIER_POINTER (dname);
9650             else
9651               {
9652                 if (IDENTIFIER_TYPENAME_P (dname))
9653                   {
9654                     my_friendly_assert (flags == NO_SPECIAL, 154);
9655                     flags = TYPENAME_FLAG;
9656                     ctor_return_type = TREE_TYPE (dname);
9657                     sfk = sfk_conversion;
9658                   }
9659                 name = operator_name_string (dname);
9660               }
9661             break;
9662
9663             /* C++ extension */
9664           case SCOPE_REF:
9665             {
9666               /* Perform error checking, and decide on a ctype.  */
9667               tree cname = TREE_OPERAND (decl, 0);
9668               if (cname == NULL_TREE)
9669                 ctype = NULL_TREE;
9670               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9671                 {
9672                   ctype = NULL_TREE;
9673                   in_namespace = TREE_OPERAND (decl, 0);
9674                   TREE_OPERAND (decl, 0) = NULL_TREE;
9675                 }
9676               else if (! is_aggr_type (cname, 1))
9677                 TREE_OPERAND (decl, 0) = NULL_TREE;
9678               /* Must test TREE_OPERAND (decl, 1), in case user gives
9679                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9680               else if (TREE_OPERAND (decl, 1)
9681                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9682                 ctype = cname;
9683               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9684                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9685                 {
9686                   cp_error ("`%T::%D' is not a valid declarator", cname,
9687                             TREE_OPERAND (decl, 1));
9688                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9689                             cname, TREE_OPERAND (decl, 1));
9690                   return void_type_node;
9691                 }
9692               else if (ctype == NULL_TREE)
9693                 ctype = cname;
9694               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9695                 TREE_OPERAND (decl, 0) = ctype;
9696               else
9697                 {
9698                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9699                     {
9700                       cp_error ("type `%T' is not derived from type `%T'",
9701                                 cname, ctype);
9702                       TREE_OPERAND (decl, 0) = NULL_TREE;
9703                     }
9704                   else
9705                     ctype = cname;
9706                 }
9707
9708               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9709                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9710                        == constructor_name_full (ctype))
9711                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9712                           == constructor_name (ctype))))
9713                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9714               next = &TREE_OPERAND (decl, 1);
9715               decl = *next;
9716               if (ctype)
9717                 {
9718                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9719                       && constructor_name (ctype) == decl)
9720                     {
9721                       sfk = sfk_constructor;
9722                       ctor_return_type = ctype;
9723                     }
9724                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9725                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9726                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9727                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9728                     {
9729                       sfk = sfk_destructor;
9730                       ctor_return_type = ctype;
9731                       flags = DTOR_FLAG;
9732                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9733                       next = &TREE_OPERAND (decl, 0);
9734                     }
9735                 }
9736             }
9737             break;
9738
9739           case ERROR_MARK:
9740             next = 0;
9741             break;
9742
9743           case TYPE_DECL:
9744             /* Parse error puts this typespec where
9745                a declarator should go.  */
9746             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9747             if (TREE_TYPE (decl) == current_class_type)
9748               cp_error ("  perhaps you want `%T' for a constructor",
9749                         current_class_name);
9750             dname = DECL_NAME (decl);
9751             name = IDENTIFIER_POINTER (dname);
9752
9753             /* Avoid giving two errors for this.  */
9754             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9755
9756             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9757             *next = dname;
9758             next = 0;
9759             break;
9760
9761           default:
9762             cp_compiler_error ("`%D' as declarator", decl);
9763             return 0; /* We used to do a 155 abort here.  */
9764           }
9765       }
9766   }
9767
9768   /* A function definition's declarator must have the form of
9769      a function declarator.  */
9770
9771   if (funcdef_flag && innermost_code != CALL_EXPR)
9772     return 0;
9773
9774   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9775       && innermost_code != CALL_EXPR
9776       && ! (ctype && declspecs == NULL_TREE))
9777     {
9778       cp_error ("declaration of `%D' as non-function", dname);
9779       return void_type_node;
9780     }
9781
9782   /* Anything declared one level down from the top level
9783      must be one of the parameters of a function
9784      (because the body is at least two levels down).  */
9785
9786   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9787      by not allowing C++ class definitions to specify their parameters
9788      with xdecls (must be spec.d in the parmlist).
9789
9790      Since we now wait to push a class scope until we are sure that
9791      we are in a legitimate method context, we must set oldcname
9792      explicitly (since current_class_name is not yet alive).
9793
9794      We also want to avoid calling this a PARM if it is in a namespace.  */
9795
9796   if (decl_context == NORMAL && !toplevel_bindings_p ())
9797     {
9798       struct binding_level *b = current_binding_level;
9799       current_binding_level = b->level_chain;
9800       if (current_binding_level != 0 && toplevel_bindings_p ())
9801         decl_context = PARM;
9802       current_binding_level = b;
9803     }
9804
9805   if (name == NULL)
9806     name = decl_context == PARM ? "parameter" : "type name";
9807
9808   /* Look through the decl specs and record which ones appear.
9809      Some typespecs are defined as built-in typenames.
9810      Others, the ones that are modifiers of other types,
9811      are represented by bits in SPECBITS: set the bits for
9812      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9813
9814      If there is a typedef name or a type, store the type in TYPE.
9815      This includes builtin typedefs such as `int'.
9816
9817      Set EXPLICIT_INT if the type is `int' or `char' and did not
9818      come from a user typedef.
9819
9820      Set LONGLONG if `long' is mentioned twice.
9821
9822      For C++, constructors and destructors have their own fast treatment.  */
9823
9824   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9825     {
9826       register int i;
9827       register tree id;
9828
9829       /* Certain parse errors slip through.  For example,
9830          `int class;' is not caught by the parser. Try
9831          weakly to recover here.  */
9832       if (TREE_CODE (spec) != TREE_LIST)
9833         return 0;
9834
9835       id = TREE_VALUE (spec);
9836
9837       if (TREE_CODE (id) == IDENTIFIER_NODE)
9838         {
9839           if (id == ridpointers[(int) RID_INT]
9840               || id == ridpointers[(int) RID_CHAR]
9841               || id == ridpointers[(int) RID_BOOL]
9842               || id == ridpointers[(int) RID_WCHAR])
9843             {
9844               if (type)
9845                 {
9846                   if (id == ridpointers[(int) RID_BOOL])
9847                     error ("`bool' is now a keyword");
9848                   else
9849                     cp_error ("extraneous `%T' ignored", id);
9850                 }
9851               else
9852                 {
9853                   if (id == ridpointers[(int) RID_INT])
9854                     explicit_int = 1;
9855                   else if (id == ridpointers[(int) RID_CHAR])
9856                     explicit_char = 1;
9857                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9858                 }
9859               goto found;
9860             }
9861           /* C++ aggregate types.  */
9862           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9863             {
9864               if (type)
9865                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9866               else
9867                 type = IDENTIFIER_TYPE_VALUE (id);
9868               goto found;
9869             }
9870
9871           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9872             {
9873               if (ridpointers[i] == id)
9874                 {
9875                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9876                     {
9877                       if (pedantic && ! in_system_header && warn_long_long)
9878                         pedwarn ("ISO C++ does not support `long long'");
9879                       if (longlong)
9880                         error ("`long long long' is too long for GCC");
9881                       else
9882                         longlong = 1;
9883                     }
9884                   else if (RIDBIT_SETP (i, specbits))
9885                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9886                   RIDBIT_SET (i, specbits);
9887                   goto found;
9888                 }
9889             }
9890         }
9891       /* C++ aggregate types.  */
9892       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9893         {
9894           if (type)
9895             cp_error ("multiple declarations `%T' and `%T'", type,
9896                       TREE_TYPE (id));
9897           else
9898             {
9899               type = TREE_TYPE (id);
9900               TREE_VALUE (spec) = type;
9901             }
9902           goto found;
9903         }
9904       if (type)
9905         error ("two or more data types in declaration of `%s'", name);
9906       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9907         {
9908           register tree t = lookup_name (id, 1);
9909           if (!t || TREE_CODE (t) != TYPE_DECL)
9910             error ("`%s' fails to be a typedef or built in type",
9911                    IDENTIFIER_POINTER (id));
9912           else
9913             {
9914               type = TREE_TYPE (t);
9915 #if 0
9916               /* See the code below that used this.  */
9917               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9918 #endif
9919               typedef_decl = t;
9920             }
9921         }
9922       else if (id != error_mark_node)
9923         /* Can't change CLASS nodes into RECORD nodes here!  */
9924         type = id;
9925
9926     found: ;
9927     }
9928
9929   typedef_type = type;
9930
9931   /* No type at all: default to `int', and set DEFAULTED_INT
9932      because it was not a user-defined typedef.  */
9933
9934   if (type == NULL_TREE
9935       && (RIDBIT_SETP (RID_SIGNED, specbits)
9936           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9937           || RIDBIT_SETP (RID_LONG, specbits)
9938           || RIDBIT_SETP (RID_SHORT, specbits)))
9939     {
9940       /* These imply 'int'.  */
9941       type = integer_type_node;
9942       defaulted_int = 1;
9943     }
9944
9945   if (sfk != sfk_none)
9946     type = check_special_function_return_type (sfk, type,
9947                                                ctor_return_type,
9948                                                ctor_return_type);
9949   else if (type == NULL_TREE)
9950     {
9951       int is_main;
9952
9953       explicit_int = -1;
9954
9955           /* We handle `main' specially here, because 'main () { }' is so
9956              common.  With no options, it is allowed.  With -Wreturn-type,
9957              it is a warning.  It is only an error with -pedantic-errors.  */
9958       is_main = (funcdef_flag
9959                  && MAIN_NAME_P (dname)
9960                  && ctype == NULL_TREE
9961                  && in_namespace == NULL_TREE
9962                  && current_namespace == global_namespace);
9963
9964       if (in_system_header || flag_ms_extensions)
9965         /* Allow it, sigh.  */;
9966       else if (pedantic || ! is_main)
9967         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
9968                     name);
9969       else if (warn_return_type)
9970         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
9971                     name);
9972
9973       type = integer_type_node;
9974     }
9975
9976   ctype = NULL_TREE;
9977
9978   /* Now process the modifiers that were specified
9979      and check for invalid combinations.  */
9980
9981   /* Long double is a special combination.  */
9982
9983   if (RIDBIT_SETP (RID_LONG, specbits)
9984       && TYPE_MAIN_VARIANT (type) == double_type_node)
9985     {
9986       RIDBIT_RESET (RID_LONG, specbits);
9987       type = build_qualified_type (long_double_type_node,
9988                                    CP_TYPE_QUALS (type));
9989     }
9990
9991   /* Check all other uses of type modifiers.  */
9992
9993   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9994       || RIDBIT_SETP (RID_SIGNED, specbits)
9995       || RIDBIT_SETP (RID_LONG, specbits)
9996       || RIDBIT_SETP (RID_SHORT, specbits))
9997     {
9998       int ok = 0;
9999
10000       if (TREE_CODE (type) == REAL_TYPE)
10001         error ("short, signed or unsigned invalid for `%s'", name);
10002       else if (TREE_CODE (type) != INTEGER_TYPE)
10003         error ("long, short, signed or unsigned invalid for `%s'", name);
10004       else if (RIDBIT_SETP (RID_LONG, specbits)
10005                && RIDBIT_SETP (RID_SHORT, specbits))
10006         error ("long and short specified together for `%s'", name);
10007       else if ((RIDBIT_SETP (RID_LONG, specbits)
10008                 || RIDBIT_SETP (RID_SHORT, specbits))
10009                && explicit_char)
10010         error ("long or short specified with char for `%s'", name);
10011       else if ((RIDBIT_SETP (RID_LONG, specbits)
10012                 || RIDBIT_SETP (RID_SHORT, specbits))
10013                && TREE_CODE (type) == REAL_TYPE)
10014         error ("long or short specified with floating type for `%s'", name);
10015       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10016                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10017         error ("signed and unsigned given together for `%s'", name);
10018       else
10019         {
10020           ok = 1;
10021           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10022             {
10023               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10024                        name);
10025               if (flag_pedantic_errors)
10026                 ok = 0;
10027             }
10028         }
10029
10030       /* Discard the type modifiers if they are invalid.  */
10031       if (! ok)
10032         {
10033           RIDBIT_RESET (RID_UNSIGNED, specbits);
10034           RIDBIT_RESET (RID_SIGNED, specbits);
10035           RIDBIT_RESET (RID_LONG, specbits);
10036           RIDBIT_RESET (RID_SHORT, specbits);
10037           longlong = 0;
10038         }
10039     }
10040
10041   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10042       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10043     {
10044       error ("complex invalid for `%s'", name);
10045       RIDBIT_RESET (RID_COMPLEX, specbits);
10046     }
10047
10048   /* Decide whether an integer type is signed or not.
10049      Optionally treat bitfields as signed by default.  */
10050   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10051       /* [class.bit]
10052
10053          It is implementation-defined whether a plain (neither
10054          explicitly signed or unsigned) char, short, int, or long
10055          bit-field is signed or unsigned.
10056
10057          Naturally, we extend this to long long as well.  Note that
10058          this does not include wchar_t.  */
10059       || (bitfield && !flag_signed_bitfields
10060           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10061           /* A typedef for plain `int' without `signed' can be
10062              controlled just like plain `int', but a typedef for
10063              `signed int' cannot be so controlled.  */
10064           && !(typedef_decl
10065                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10066           && (TREE_CODE (type) == INTEGER_TYPE
10067               || TREE_CODE (type) == CHAR_TYPE)
10068           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10069     {
10070       if (longlong)
10071         type = long_long_unsigned_type_node;
10072       else if (RIDBIT_SETP (RID_LONG, specbits))
10073         type = long_unsigned_type_node;
10074       else if (RIDBIT_SETP (RID_SHORT, specbits))
10075         type = short_unsigned_type_node;
10076       else if (type == char_type_node)
10077         type = unsigned_char_type_node;
10078       else if (typedef_decl)
10079         type = unsigned_type (type);
10080       else
10081         type = unsigned_type_node;
10082     }
10083   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10084            && type == char_type_node)
10085     type = signed_char_type_node;
10086   else if (longlong)
10087     type = long_long_integer_type_node;
10088   else if (RIDBIT_SETP (RID_LONG, specbits))
10089     type = long_integer_type_node;
10090   else if (RIDBIT_SETP (RID_SHORT, specbits))
10091     type = short_integer_type_node;
10092
10093   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10094     {
10095       /* If we just have "complex", it is equivalent to
10096          "complex double", but if any modifiers at all are specified it is
10097          the complex form of TYPE.  E.g, "complex short" is
10098          "complex short int".  */
10099
10100       if (defaulted_int && ! longlong
10101           && ! (RIDBIT_SETP (RID_LONG, specbits)
10102                 || RIDBIT_SETP (RID_SHORT, specbits)
10103                 || RIDBIT_SETP (RID_SIGNED, specbits)
10104                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10105         type = complex_double_type_node;
10106       else if (type == integer_type_node)
10107         type = complex_integer_type_node;
10108       else if (type == float_type_node)
10109         type = complex_float_type_node;
10110       else if (type == double_type_node)
10111         type = complex_double_type_node;
10112       else if (type == long_double_type_node)
10113         type = complex_long_double_type_node;
10114       else
10115         type = build_complex_type (type);
10116     }
10117
10118   if (sfk == sfk_conversion
10119       && (RIDBIT_SETP (RID_CONST, specbits)
10120           || RIDBIT_SETP (RID_VOLATILE, specbits)
10121           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10122     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10123               ctor_return_type);
10124
10125   /* Set CONSTP if this declaration is `const', whether by
10126      explicit specification or via a typedef.
10127      Likewise for VOLATILEP.  */
10128
10129   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10130   restrictp =
10131     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10132   volatilep =
10133     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10134   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10135                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10136                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10137   type = cp_build_qualified_type (type, type_quals);
10138   staticp = 0;
10139   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10140   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10141   RIDBIT_RESET (RID_VIRTUAL, specbits);
10142   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10143   RIDBIT_RESET (RID_EXPLICIT, specbits);
10144
10145   if (RIDBIT_SETP (RID_STATIC, specbits))
10146     staticp = 1 + (decl_context == FIELD);
10147
10148   if (virtualp && staticp == 2)
10149     {
10150       cp_error ("member `%D' cannot be declared both virtual and static",
10151                 dname);
10152       staticp = 0;
10153     }
10154   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10155   RIDBIT_RESET (RID_FRIEND, specbits);
10156
10157   /* Warn if two storage classes are given. Default to `auto'.  */
10158
10159   if (RIDBIT_ANY_SET (specbits))
10160     {
10161       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10162       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10163       if (decl_context == PARM && nclasses > 0)
10164         error ("storage class specifiers invalid in parameter declarations");
10165       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10166         {
10167           if (decl_context == PARM)
10168             error ("typedef declaration invalid in parameter declaration");
10169           nclasses++;
10170         }
10171       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10172       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10173     }
10174
10175   /* Give error if `virtual' is used outside of class declaration.  */
10176   if (virtualp
10177       && (current_class_name == NULL_TREE || decl_context != FIELD))
10178     {
10179       error ("virtual outside class declaration");
10180       virtualp = 0;
10181     }
10182
10183   /* Static anonymous unions are dealt with here.  */
10184   if (staticp && decl_context == TYPENAME
10185       && TREE_CODE (declspecs) == TREE_LIST
10186       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10187     decl_context = FIELD;
10188
10189   /* Warn about storage classes that are invalid for certain
10190      kinds of declarations (parameters, typenames, etc.).  */
10191
10192   if (nclasses > 1)
10193     error ("multiple storage classes in declaration of `%s'", name);
10194   else if (decl_context != NORMAL && nclasses > 0)
10195     {
10196       if ((decl_context == PARM || decl_context == CATCHPARM)
10197           && (RIDBIT_SETP (RID_REGISTER, specbits)
10198               || RIDBIT_SETP (RID_AUTO, specbits)))
10199         ;
10200       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10201         ;
10202       else if (decl_context == FIELD
10203                /* C++ allows static class elements  */
10204                && RIDBIT_SETP (RID_STATIC, specbits))
10205         /* C++ also allows inlines and signed and unsigned elements,
10206            but in those cases we don't come in here.  */
10207         ;
10208       else
10209         {
10210           if (decl_context == FIELD)
10211             {
10212               tree tmp = NULL_TREE;
10213               register int op = 0;
10214
10215               if (declarator)
10216                 {
10217                   /* Avoid trying to get an operand off an identifier node.  */
10218                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10219                     tmp = declarator;
10220                   else
10221                     tmp = TREE_OPERAND (declarator, 0);
10222                   op = IDENTIFIER_OPNAME_P (tmp);
10223                 }
10224               error ("storage class specified for %s `%s'",
10225                      op ? "member operator" : "field",
10226                      op ? operator_name_string (tmp) : name);
10227             }
10228           else
10229             {
10230               if (decl_context == PARM || decl_context == CATCHPARM)
10231                 error ("storage class specified for parameter `%s'", name);
10232               else
10233                 error ("storage class specified for typename");
10234             }
10235           RIDBIT_RESET (RID_REGISTER, specbits);
10236           RIDBIT_RESET (RID_AUTO, specbits);
10237           RIDBIT_RESET (RID_EXTERN, specbits);
10238         }
10239     }
10240   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10241     {
10242       if (toplevel_bindings_p ())
10243         {
10244           /* It's common practice (and completely valid) to have a const
10245              be initialized and declared extern.  */
10246           if (!(type_quals & TYPE_QUAL_CONST))
10247             warning ("`%s' initialized and declared `extern'", name);
10248         }
10249       else
10250         error ("`%s' has both `extern' and initializer", name);
10251     }
10252   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10253            && ! toplevel_bindings_p ())
10254     error ("nested function `%s' declared `extern'", name);
10255   else if (toplevel_bindings_p ())
10256     {
10257       if (RIDBIT_SETP (RID_AUTO, specbits))
10258         error ("top-level declaration of `%s' specifies `auto'", name);
10259     }
10260
10261   if (nclasses > 0 && friendp)
10262     error ("storage class specifiers invalid in friend function declarations");
10263
10264   /* Now figure out the structure of the declarator proper.
10265      Descend through it, creating more complex types, until we reach
10266      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10267
10268   inner_attrs = NULL_TREE;
10269   ignore_attrs = 0;
10270
10271   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10272          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10273     {
10274       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10275          an INDIRECT_REF (for *...),
10276          a CALL_EXPR (for ...(...)),
10277          an identifier (for the name being declared)
10278          or a null pointer (for the place in an absolute declarator
10279          where the name was omitted).
10280          For the last two cases, we have just exited the loop.
10281
10282          For C++ it could also be
10283          a SCOPE_REF (for class :: ...).  In this case, we have converted
10284          sensible names to types, and those are the values we use to
10285          qualify the member name.
10286          an ADDR_EXPR (for &...),
10287          a BIT_NOT_EXPR (for destructors)
10288
10289          At this point, TYPE is the type of elements of an array,
10290          or for a function to return, or for a pointer to point to.
10291          After this sequence of ifs, TYPE is the type of the
10292          array or function or pointer, and DECLARATOR has had its
10293          outermost layer removed.  */
10294
10295       if (type == error_mark_node)
10296         {
10297           if (TREE_CODE (declarator) == SCOPE_REF)
10298             declarator = TREE_OPERAND (declarator, 1);
10299           else
10300             declarator = TREE_OPERAND (declarator, 0);
10301           continue;
10302         }
10303       if (quals != NULL_TREE
10304           && (declarator == NULL_TREE
10305               || TREE_CODE (declarator) != SCOPE_REF))
10306         {
10307           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10308             ctype = TYPE_METHOD_BASETYPE (type);
10309           if (ctype != NULL_TREE)
10310             {
10311               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10312               grok_method_quals (ctype, dummy, quals);
10313               type = TREE_TYPE (dummy);
10314               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10315               quals = NULL_TREE;
10316             }
10317         }
10318
10319       /* See the comment for the TREE_LIST case, below.  */
10320       if (ignore_attrs)
10321         ignore_attrs = 0;
10322       else if (inner_attrs)
10323         {
10324           decl_attributes (type, inner_attrs, NULL_TREE);
10325           inner_attrs = NULL_TREE;
10326         }
10327
10328       switch (TREE_CODE (declarator))
10329         {
10330         case TREE_LIST:
10331           {
10332             /* We encode a declarator with embedded attributes using
10333                a TREE_LIST.  The attributes apply to the declarator
10334                directly inside them, so we have to skip an iteration
10335                before applying them to the type.  If the declarator just
10336                inside is the declarator-id, we apply the attrs to the
10337                decl itself.  */
10338             inner_attrs = TREE_PURPOSE (declarator);
10339             ignore_attrs = 1;
10340             declarator = TREE_VALUE (declarator);
10341           }
10342           break;
10343
10344         case ARRAY_REF:
10345           {
10346             register tree size;
10347
10348             size = TREE_OPERAND (declarator, 1);
10349
10350             /* VC++ spells a zero-sized array with [].  */
10351             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10352                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10353               size = integer_zero_node;
10354
10355             declarator = TREE_OPERAND (declarator, 0);
10356
10357             type = create_array_type_for_decl (dname, type, size);
10358
10359             /* VLAs never work as fields. */
10360             if (decl_context == FIELD && !processing_template_decl
10361                 && TREE_CODE (type) == ARRAY_TYPE
10362                 && TYPE_DOMAIN (type) != NULL_TREE
10363                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10364               {
10365                 cp_error ("size of member `%D' is not constant", dname);
10366                 /* Proceed with arbitrary constant size, so that offset
10367                    computations don't get confused. */
10368                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10369                                                    integer_one_node);
10370               }
10371
10372             ctype = NULL_TREE;
10373           }
10374           break;
10375
10376         case CALL_EXPR:
10377           {
10378             tree arg_types;
10379             int funcdecl_p;
10380             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10381             tree inner_decl = TREE_OPERAND (declarator, 0);
10382
10383             /* Declaring a function type.
10384                Make sure we have a valid type for the function to return.  */
10385
10386             /* We now know that the TYPE_QUALS don't apply to the
10387                decl, but to its return type.  */
10388             type_quals = TYPE_UNQUALIFIED;
10389
10390             /* Warn about some types functions can't return.  */
10391
10392             if (TREE_CODE (type) == FUNCTION_TYPE)
10393               {
10394                 error ("`%s' declared as function returning a function", name);
10395                 type = integer_type_node;
10396               }
10397             if (TREE_CODE (type) == ARRAY_TYPE)
10398               {
10399                 error ("`%s' declared as function returning an array", name);
10400                 type = integer_type_node;
10401               }
10402
10403             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10404               inner_decl = TREE_OPERAND (inner_decl, 1);
10405
10406             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10407               inner_decl = dname;
10408
10409             /* Pick up type qualifiers which should be applied to `this'.  */
10410             quals = CALL_DECLARATOR_QUALS (declarator);
10411
10412             /* Pick up the exception specifications.  */
10413             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10414
10415             /* Say it's a definition only for the CALL_EXPR
10416                closest to the identifier.  */
10417             funcdecl_p
10418               = inner_decl
10419               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10420                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10421                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10422
10423             if (ctype == NULL_TREE
10424                 && decl_context == FIELD
10425                 && funcdecl_p
10426                 && (friendp == 0 || dname == current_class_name))
10427               ctype = current_class_type;
10428
10429             if (ctype && sfk == sfk_conversion)
10430               TYPE_HAS_CONVERSION (ctype) = 1;
10431             if (ctype && constructor_name (ctype) == dname)
10432               {
10433                 /* We are within a class's scope. If our declarator name
10434                    is the same as the class name, and we are defining
10435                    a function, then it is a constructor/destructor, and
10436                    therefore returns a void type.  */
10437
10438                 if (flags == DTOR_FLAG)
10439                   {
10440                     /* ISO C++ 12.4/2.  A destructor may not be
10441                        declared const or volatile.  A destructor may
10442                        not be static.  */
10443                     if (staticp == 2)
10444                       error ("destructor cannot be static member function");
10445                     if (quals)
10446                       {
10447                         cp_error ("destructors may not be `%s'",
10448                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10449                         quals = NULL_TREE;
10450                       }
10451                     if (decl_context == FIELD)
10452                       {
10453                         if (! member_function_or_else (ctype,
10454                                                        current_class_type,
10455                                                        flags))
10456                           return void_type_node;
10457                       }
10458                   }
10459                 else            /* It's a constructor.  */
10460                   {
10461                     if (explicitp == 1)
10462                       explicitp = 2;
10463                     /* ISO C++ 12.1.  A constructor may not be
10464                        declared const or volatile.  A constructor may
10465                        not be virtual.  A constructor may not be
10466                        static.  */
10467                     if (staticp == 2)
10468                       error ("constructor cannot be static member function");
10469                     if (virtualp)
10470                       {
10471                         pedwarn ("constructors cannot be declared virtual");
10472                         virtualp = 0;
10473                       }
10474                     if (quals)
10475                       {
10476                         cp_error ("constructors may not be `%s'",
10477                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10478                         quals = NULL_TREE;
10479                       }
10480                     {
10481                       RID_BIT_TYPE tmp_bits;
10482                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10483                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10484                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10485                       if (RIDBIT_ANY_SET (tmp_bits))
10486                         error ("return value type specifier for constructor ignored");
10487                     }
10488                     if (decl_context == FIELD)
10489                       {
10490                         if (! member_function_or_else (ctype,
10491                                                        current_class_type,
10492                                                        flags))
10493                           return void_type_node;
10494                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10495                         if (sfk != sfk_constructor)
10496                           return NULL_TREE;
10497                       }
10498                   }
10499                 if (decl_context == FIELD)
10500                   staticp = 0;
10501               }
10502             else if (friendp)
10503               {
10504                 if (initialized)
10505                   error ("can't initialize friend function `%s'", name);
10506                 if (virtualp)
10507                   {
10508                     /* Cannot be both friend and virtual.  */
10509                     error ("virtual functions cannot be friends");
10510                     RIDBIT_RESET (RID_FRIEND, specbits);
10511                     friendp = 0;
10512                   }
10513                 if (decl_context == NORMAL)
10514                   error ("friend declaration not in class definition");
10515                 if (current_function_decl && funcdef_flag)
10516                   cp_error ("can't define friend function `%s' in a local class definition",
10517                             name);
10518               }
10519
10520             /* Construct the function type and go to the next
10521                inner layer of declarator.  */
10522
10523             declarator = TREE_OPERAND (declarator, 0);
10524
10525             /* FIXME: This is where default args should be fully
10526                processed.  */
10527
10528             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10529
10530             if (declarator && flags == DTOR_FLAG)
10531               {
10532                 /* A destructor declared in the body of a class will
10533                    be represented as a BIT_NOT_EXPR.  But, we just
10534                    want the underlying IDENTIFIER.  */
10535                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10536                   declarator = TREE_OPERAND (declarator, 0);
10537
10538                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10539                   arg_types = void_list_node;
10540                 else if (arg_types == NULL_TREE
10541                          || arg_types != void_list_node)
10542                   {
10543                     cp_error ("destructors may not have parameters");
10544                     arg_types = void_list_node;
10545                     last_function_parms = NULL_TREE;
10546                   }
10547               }
10548
10549             /* ANSI says that `const int foo ();'
10550                does not make the function foo const.  */
10551             type = build_function_type (type, arg_types);
10552
10553             {
10554               tree t;
10555               for (t = arg_types; t; t = TREE_CHAIN (t))
10556                 if (TREE_PURPOSE (t)
10557                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10558                   {
10559                     add_defarg_fn (type);
10560                     break;
10561                   }
10562             }
10563           }
10564           break;
10565
10566         case ADDR_EXPR:
10567         case INDIRECT_REF:
10568           /* Filter out pointers-to-references and references-to-references.
10569              We can get these if a TYPE_DECL is used.  */
10570
10571           if (TREE_CODE (type) == REFERENCE_TYPE)
10572             {
10573               error ("cannot declare %s to references",
10574                      TREE_CODE (declarator) == ADDR_EXPR
10575                      ? "references" : "pointers");
10576               declarator = TREE_OPERAND (declarator, 0);
10577               continue;
10578             }
10579
10580           if (TREE_CODE (type) == OFFSET_TYPE
10581               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10582                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10583             {
10584               cp_error ("cannot declare pointer to `%#T' member",
10585                         TREE_TYPE (type));
10586               type = TREE_TYPE (type);
10587             }
10588
10589           /* Merge any constancy or volatility into the target type
10590              for the pointer.  */
10591
10592           /* We now know that the TYPE_QUALS don't apply to the decl,
10593              but to the target of the pointer.  */
10594           type_quals = TYPE_UNQUALIFIED;
10595
10596           if (TREE_CODE (declarator) == ADDR_EXPR)
10597             {
10598               if (TREE_CODE (type) == VOID_TYPE)
10599                 error ("invalid type: `void &'");
10600               else
10601                 type = build_reference_type (type);
10602             }
10603           else if (TREE_CODE (type) == METHOD_TYPE)
10604             type = build_ptrmemfunc_type (build_pointer_type (type));
10605           else
10606             type = build_pointer_type (type);
10607
10608           /* Process a list of type modifier keywords (such as
10609              const or volatile) that were given inside the `*' or `&'.  */
10610
10611           if (TREE_TYPE (declarator))
10612             {
10613               register tree typemodlist;
10614               int erred = 0;
10615
10616               constp = 0;
10617               volatilep = 0;
10618               restrictp = 0;
10619               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10620                    typemodlist = TREE_CHAIN (typemodlist))
10621                 {
10622                   tree qualifier = TREE_VALUE (typemodlist);
10623
10624                   if (qualifier == ridpointers[(int) RID_CONST])
10625                     constp++;
10626                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10627                     volatilep++;
10628                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10629                     restrictp++;
10630                   else if (!erred)
10631                     {
10632                       erred = 1;
10633                       error ("invalid type modifier within pointer declarator");
10634                     }
10635                 }
10636               if (constp > 1)
10637                 pedwarn ("duplicate `const'");
10638               if (volatilep > 1)
10639                 pedwarn ("duplicate `volatile'");
10640               if (restrictp > 1)
10641                 pedwarn ("duplicate `restrict'");
10642
10643               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10644                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10645                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10646               if (TREE_CODE (declarator) == ADDR_EXPR
10647                   && (constp || volatilep))
10648                 {
10649                   if (constp)
10650                     pedwarn ("discarding `const' applied to a reference");
10651                   if (volatilep)
10652                     pedwarn ("discarding `volatile' applied to a reference");
10653                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10654                 }
10655               type = cp_build_qualified_type (type, type_quals);
10656             }
10657           declarator = TREE_OPERAND (declarator, 0);
10658           ctype = NULL_TREE;
10659           break;
10660
10661         case SCOPE_REF:
10662           {
10663             /* We have converted type names to NULL_TREE if the
10664                name was bogus, or to a _TYPE node, if not.
10665
10666                The variable CTYPE holds the type we will ultimately
10667                resolve to.  The code here just needs to build
10668                up appropriate member types.  */
10669             tree sname = TREE_OPERAND (declarator, 1);
10670             tree t;
10671
10672             /* Destructors can have their visibilities changed as well.  */
10673             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10674               sname = TREE_OPERAND (sname, 0);
10675
10676             if (TREE_COMPLEXITY (declarator) == 0)
10677               /* This needs to be here, in case we are called
10678                  multiple times.  */ ;
10679             else if (TREE_COMPLEXITY (declarator) == -1)
10680               /* Namespace member. */
10681               pop_decl_namespace ();
10682             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10683               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10684             else if (! IS_AGGR_TYPE_CODE
10685                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10686               ;
10687             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10688               {
10689                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10690                    that refer to ctype.  They couldn't be resolved earlier
10691                    because we hadn't pushed into the class yet.
10692                    Example: resolve 'B<T>::type' in
10693                    'B<typename B<T>::type> B<T>::f () { }'.  */
10694                 if (current_template_parms
10695                     && uses_template_parms (type)
10696                     && uses_template_parms (current_class_type))
10697                   {
10698                     tree args = current_template_args ();
10699                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10700                   }
10701
10702                 /* This pop_nested_class corresponds to the
10703                    push_nested_class used to push into class scope for
10704                    parsing the argument list of a function decl, in
10705                    qualified_id.  */
10706                 pop_nested_class ();
10707                 TREE_COMPLEXITY (declarator) = current_class_depth;
10708               }
10709             else
10710               my_friendly_abort (16);
10711
10712             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10713               {
10714                 /* We had a reference to a global decl, or
10715                    perhaps we were given a non-aggregate typedef,
10716                    in which case we cleared this out, and should just
10717                    keep going as though it wasn't there.  */
10718                 declarator = sname;
10719                 continue;
10720               }
10721             ctype = TREE_OPERAND (declarator, 0);
10722
10723             t = ctype;
10724             while (t != NULL_TREE && CLASS_TYPE_P (t))
10725               {
10726                 /* You're supposed to have one `template <...>'
10727                    for every template class, but you don't need one
10728                    for a full specialization.  For example:
10729
10730                      template <class T> struct S{};
10731                      template <> struct S<int> { void f(); };
10732                      void S<int>::f () {}
10733
10734                    is correct; there shouldn't be a `template <>' for
10735                    the definition of `S<int>::f'.  */
10736                 if (CLASSTYPE_TEMPLATE_INFO (t)
10737                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10738                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10739                   template_count += 1;
10740
10741                 t = TYPE_MAIN_DECL (t);
10742                 if (DECL_LANG_SPECIFIC (t))
10743                   t = DECL_CONTEXT (t);
10744                 else
10745                   t = NULL_TREE;
10746               }
10747
10748             if (sname == NULL_TREE)
10749               goto done_scoping;
10750
10751             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10752               {
10753                 /* This is the `standard' use of the scoping operator:
10754                    basetype :: member .  */
10755
10756                 if (ctype == current_class_type)
10757                   {
10758                     /* class A {
10759                          void A::f ();
10760                        };
10761
10762                        Is this ill-formed?  */
10763
10764                     if (pedantic)
10765                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10766                                   ctype, name);
10767                   }
10768                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10769                   {
10770                     if (current_class_type == NULL_TREE
10771                         || friendp)
10772                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10773                                                       TYPE_ARG_TYPES (type));
10774                     else
10775                       {
10776                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10777                                   ctype, name, current_class_type);
10778                         return void_type_node;
10779                       }
10780                   }
10781                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10782                          || COMPLETE_TYPE_P (complete_type (ctype)))
10783                   {
10784                     /* Have to move this code elsewhere in this function.
10785                        this code is used for i.e., typedef int A::M; M *pm;
10786
10787                        It is?  How? jason 10/2/94 */
10788
10789                     if (current_class_type)
10790                       {
10791                         cp_error ("cannot declare member `%T::%s' within `%T'",
10792                                   ctype, name, current_class_type);
10793                         return void_type_node;
10794                       }
10795                     type = build_offset_type (ctype, type);
10796                   }
10797                 else if (uses_template_parms (ctype))
10798                   {
10799                     if (TREE_CODE (type) == FUNCTION_TYPE)
10800                       type
10801                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10802                                                    TYPE_ARG_TYPES (type));
10803                   }
10804                 else
10805                   {
10806                     cp_error ("structure `%T' not yet defined", ctype);
10807                     return error_mark_node;
10808                   }
10809
10810                 declarator = sname;
10811               }
10812             else if (TREE_CODE (sname) == SCOPE_REF)
10813               my_friendly_abort (17);
10814             else
10815               {
10816               done_scoping:
10817                 declarator = TREE_OPERAND (declarator, 1);
10818                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10819                   /* In this case, we will deal with it later.  */
10820                   ;
10821                 else
10822                   {
10823                     if (TREE_CODE (type) == FUNCTION_TYPE)
10824                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10825                                                       TYPE_ARG_TYPES (type));
10826                     else
10827                       type = build_offset_type (ctype, type);
10828                   }
10829               }
10830           }
10831           break;
10832
10833         case BIT_NOT_EXPR:
10834           declarator = TREE_OPERAND (declarator, 0);
10835           break;
10836
10837         case RECORD_TYPE:
10838         case UNION_TYPE:
10839         case ENUMERAL_TYPE:
10840           declarator = NULL_TREE;
10841           break;
10842
10843         case ERROR_MARK:
10844           declarator = NULL_TREE;
10845           break;
10846
10847         default:
10848           my_friendly_abort (158);
10849         }
10850     }
10851
10852   /* See the comment for the TREE_LIST case, above.  */
10853   if (inner_attrs)
10854     {
10855       if (! ignore_attrs)
10856         decl_attributes (type, inner_attrs, NULL_TREE);
10857       else if (attrlist)
10858         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10859       else
10860         attrlist = build_decl_list (NULL_TREE, inner_attrs);
10861     }
10862
10863   /* Now TYPE has the actual type.  */
10864
10865   if (explicitp == 1 || (explicitp && friendp))
10866     {
10867       /* [dcl.fct.spec] The explicit specifier shall only be used in
10868          declarations of constructors within a class definition.  */
10869       error ("only declarations of constructors can be `explicit'");
10870       explicitp = 0;
10871     }
10872
10873   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10874     {
10875       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10876         {
10877           error ("non-member `%s' cannot be declared `mutable'", name);
10878           RIDBIT_RESET (RID_MUTABLE, specbits);
10879         }
10880       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10881         {
10882           error ("non-object member `%s' cannot be declared `mutable'", name);
10883           RIDBIT_RESET (RID_MUTABLE, specbits);
10884         }
10885       else if (TREE_CODE (type) == FUNCTION_TYPE
10886                || TREE_CODE (type) == METHOD_TYPE)
10887         {
10888           error ("function `%s' cannot be declared `mutable'", name);
10889           RIDBIT_RESET (RID_MUTABLE, specbits);
10890         }
10891       else if (staticp)
10892         {
10893           error ("static `%s' cannot be declared `mutable'", name);
10894           RIDBIT_RESET (RID_MUTABLE, specbits);
10895         }
10896       else if (type_quals & TYPE_QUAL_CONST)
10897         {
10898           error ("const `%s' cannot be declared `mutable'", name);
10899           RIDBIT_RESET (RID_MUTABLE, specbits);
10900         }
10901     }
10902
10903   if (declarator == NULL_TREE
10904       || TREE_CODE (declarator) == IDENTIFIER_NODE
10905       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10906           && (TREE_CODE (type) == FUNCTION_TYPE
10907               || TREE_CODE (type) == METHOD_TYPE)))
10908     /* OK */;
10909   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10910     {
10911       cp_error ("template-id `%D' used as a declarator", declarator);
10912       declarator = dname;
10913     }
10914   else
10915     /* Unexpected declarator format.  */
10916     my_friendly_abort (990210);
10917
10918   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10919
10920   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10921     {
10922       tree decl;
10923
10924       /* Note that the grammar rejects storage classes
10925          in typenames, fields or parameters.  */
10926       if (current_lang_name == lang_name_java)
10927         TYPE_FOR_JAVA (type) = 1;
10928
10929       if (decl_context == FIELD)
10930         {
10931           if (declarator == constructor_name (current_class_type))
10932             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10933                         declarator);
10934           decl = build_lang_decl (TYPE_DECL, declarator, type);
10935         }
10936       else
10937         decl = build_decl (TYPE_DECL, declarator, type);
10938
10939       /* If the user declares "typedef struct {...} foo" then the
10940          struct will have an anonymous name.  Fill that name in now.
10941          Nothing can refer to it, so nothing needs know about the name
10942          change.  */
10943       if (type != error_mark_node
10944           && declarator
10945           && TYPE_NAME (type)
10946           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10947           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10948           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10949         {
10950           tree oldname = TYPE_NAME (type);
10951           tree t;
10952
10953           /* Replace the anonymous name with the real name everywhere.  */
10954           lookup_tag_reverse (type, declarator);
10955           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10956             if (TYPE_NAME (t) == oldname)
10957               TYPE_NAME (t) = decl;
10958
10959           if (TYPE_LANG_SPECIFIC (type))
10960             TYPE_WAS_ANONYMOUS (type) = 1;
10961
10962           /* If this is a typedef within a template class, the nested
10963              type is a (non-primary) template.  The name for the
10964              template needs updating as well.  */
10965           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10966             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10967               = TYPE_IDENTIFIER (type);
10968
10969           /* XXX Temporarily set the scope.
10970              When returning, start_decl expects it as NULL_TREE,
10971              and will then then set it using pushdecl. */
10972           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10973           if (current_class_type)
10974             DECL_CONTEXT (decl) = current_class_type;
10975           else
10976             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10977
10978           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10979           DECL_ASSEMBLER_NAME (decl)
10980             = get_identifier (build_overload_name (type, 1, 1));
10981           DECL_CONTEXT (decl) = NULL_TREE;
10982
10983           /* FIXME remangle member functions; member functions of a
10984              type with external linkage have external linkage.  */
10985         }
10986
10987       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10988         {
10989           cp_error_at ("typedef name may not be class-qualified", decl);
10990           return NULL_TREE;
10991         }
10992       else if (quals)
10993         {
10994           if (ctype == NULL_TREE)
10995             {
10996               if (TREE_CODE (type) != METHOD_TYPE)
10997                 cp_error_at ("invalid type qualifier for non-member function type", decl);
10998               else
10999                 ctype = TYPE_METHOD_BASETYPE (type);
11000             }
11001           if (ctype != NULL_TREE)
11002             grok_method_quals (ctype, decl, quals);
11003         }
11004
11005       if (RIDBIT_SETP (RID_SIGNED, specbits)
11006           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11007         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11008
11009       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11010                       inlinep, friendp, raises != NULL_TREE);
11011
11012       if (initialized)
11013         error ("typedef declaration includes an initializer");
11014
11015       return decl;
11016     }
11017
11018   /* Detect the case of an array type of unspecified size
11019      which came, as such, direct from a typedef name.
11020      We must copy the type, so that each identifier gets
11021      a distinct type, so that each identifier's size can be
11022      controlled separately by its own initializer.  */
11023
11024   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11025       && TYPE_DOMAIN (type) == NULL_TREE)
11026     {
11027       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11028     }
11029
11030   /* If this is a type name (such as, in a cast or sizeof),
11031      compute the type and return it now.  */
11032
11033   if (decl_context == TYPENAME)
11034     {
11035       /* Note that the grammar rejects storage classes
11036          in typenames, fields or parameters.  */
11037       if (type_quals != TYPE_UNQUALIFIED)
11038         type_quals = TYPE_UNQUALIFIED;
11039
11040       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11041       if (friendp)
11042         {
11043           if (type_quals != TYPE_UNQUALIFIED)
11044             {
11045               cp_error ("type qualifiers specified for friend class declaration");
11046               type_quals = TYPE_UNQUALIFIED;
11047             }
11048           if (inlinep)
11049             {
11050               cp_error ("`inline' specified for friend class declaration");
11051               inlinep = 0;
11052             }
11053
11054           /* Only try to do this stuff if we didn't already give up.  */
11055           if (type != integer_type_node)
11056             {
11057               /* A friendly class?  */
11058               if (current_class_type)
11059                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11060               else
11061                 error ("trying to make class `%s' a friend of global scope",
11062                        TYPE_NAME_STRING (type));
11063               type = void_type_node;
11064             }
11065         }
11066       else if (quals)
11067         {
11068           if (ctype == NULL_TREE)
11069             {
11070               if (TREE_CODE (type) != METHOD_TYPE)
11071                 cp_error ("invalid qualifiers on non-member function type");
11072               else
11073                 ctype = TYPE_METHOD_BASETYPE (type);
11074             }
11075           if (ctype)
11076             {
11077               tree dummy = build_decl (TYPE_DECL, declarator, type);
11078               grok_method_quals (ctype, dummy, quals);
11079               type = TREE_TYPE (dummy);
11080             }
11081         }
11082
11083       return type;
11084     }
11085   else if (declarator == NULL_TREE && decl_context != PARM
11086            && decl_context != CATCHPARM
11087            && TREE_CODE (type) != UNION_TYPE
11088            && ! bitfield)
11089     {
11090       cp_error ("abstract declarator `%T' used as declaration", type);
11091       declarator = make_anon_name ();
11092     }
11093
11094   /* `void' at top level (not within pointer)
11095      is allowed only in typedefs or type names.
11096      We don't complain about parms either, but that is because
11097      a better error message can be made later.  */
11098
11099   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11100     {
11101       if (! declarator)
11102         error ("unnamed variable or field declared void");
11103       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11104         {
11105           if (IDENTIFIER_OPNAME_P (declarator))
11106             my_friendly_abort (356);
11107           else
11108             error ("variable or field `%s' declared void", name);
11109         }
11110       else
11111         error ("variable or field declared void");
11112       type = integer_type_node;
11113     }
11114
11115   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11116      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11117
11118   if (decl_context == PARM || decl_context == CATCHPARM)
11119     {
11120       if (ctype || in_namespace)
11121         error ("cannot use `::' in parameter declaration");
11122
11123       /* A parameter declared as an array of T is really a pointer to T.
11124          One declared as a function is really a pointer to a function.
11125          One declared as a member is really a pointer to member.  */
11126
11127       if (TREE_CODE (type) == ARRAY_TYPE)
11128         {
11129           /* Transfer const-ness of array into that of type pointed to.  */
11130           type = build_pointer_type (TREE_TYPE (type));
11131           type_quals = TYPE_UNQUALIFIED;
11132         }
11133       else if (TREE_CODE (type) == FUNCTION_TYPE)
11134         type = build_pointer_type (type);
11135       else if (TREE_CODE (type) == OFFSET_TYPE)
11136         type = build_pointer_type (type);
11137       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11138         {
11139           error ("declaration of `%s' as void", name);
11140           return NULL_TREE;
11141         }
11142     }
11143
11144   {
11145     register tree decl;
11146
11147     if (decl_context == PARM)
11148       {
11149         decl = build_decl (PARM_DECL, declarator, type);
11150
11151         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11152                         inlinep, friendp, raises != NULL_TREE);
11153
11154         /* Compute the type actually passed in the parmlist,
11155            for the case where there is no prototype.
11156            (For example, shorts and chars are passed as ints.)
11157            When there is a prototype, this is overridden later.  */
11158
11159         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11160       }
11161     else if (decl_context == FIELD)
11162       {
11163         if (type == error_mark_node)
11164           {
11165             /* Happens when declaring arrays of sizes which
11166                are error_mark_node, for example.  */
11167             decl = NULL_TREE;
11168           }
11169         else if (in_namespace && !friendp)
11170           {
11171             /* Something like struct S { int N::j; };  */
11172             cp_error ("invalid use of `::'");
11173             decl = NULL_TREE;
11174           }
11175         else if (TREE_CODE (type) == FUNCTION_TYPE)
11176           {
11177             int publicp = 0;
11178             tree function_context;
11179
11180             /* We catch the others as conflicts with the builtin
11181                typedefs.  */
11182             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11183               {
11184                 cp_error ("function `%D' cannot be declared friend",
11185                           declarator);
11186                 friendp = 0;
11187               }
11188
11189             if (friendp == 0)
11190               {
11191                 if (ctype == NULL_TREE)
11192                   ctype = current_class_type;
11193
11194                 if (ctype == NULL_TREE)
11195                   {
11196                     cp_error ("can't make `%D' into a method -- not in a class",
11197                               declarator);
11198                     return void_type_node;
11199                   }
11200
11201                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11202                    ARM 9.5 */
11203                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11204                   {
11205                     cp_error ("function `%D' declared virtual inside a union",
11206                               declarator);
11207                     return void_type_node;
11208                   }
11209
11210                 if (declarator == ansi_opname[(int) NEW_EXPR]
11211                     || declarator == ansi_opname[(int) VEC_NEW_EXPR]
11212                     || declarator == ansi_opname[(int) DELETE_EXPR]
11213                     || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
11214                   {
11215                     if (virtualp)
11216                       {
11217                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11218                                   declarator);
11219                         virtualp = 0;
11220                       }
11221                   }
11222                 else if (staticp < 2)
11223                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11224                                                   TYPE_ARG_TYPES (type));
11225               }
11226
11227             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11228             function_context = (ctype != NULL_TREE) ?
11229               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11230             publicp = (! friendp || ! staticp)
11231               && function_context == NULL_TREE;
11232             decl = grokfndecl (ctype, type,
11233                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11234                                ? declarator : dname,
11235                                declarator,
11236                                virtualp, flags, quals, raises,
11237                                friendp ? -1 : 0, friendp, publicp, inlinep,
11238                                funcdef_flag, template_count, in_namespace);
11239             if (decl == NULL_TREE)
11240               return decl;
11241 #if 0
11242             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11243             /* The decl and setting of decl_machine_attr is also turned off.  */
11244             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11245 #endif
11246
11247             /* [class.conv.ctor]
11248
11249                A constructor declared without the function-specifier
11250                explicit that can be called with a single parameter
11251                specifies a conversion from the type of its first
11252                parameter to the type of its class.  Such a constructor
11253                is called a converting constructor.  */
11254             if (explicitp == 2)
11255               DECL_NONCONVERTING_P (decl) = 1;
11256             else if (DECL_CONSTRUCTOR_P (decl))
11257               {
11258                 /* The constructor can be called with exactly one
11259                    parameter if there is at least one parameter, and
11260                    any subsequent parameters have default arguments.
11261                    We don't look at the first parameter, which is
11262                    really just the `this' parameter for the new
11263                    object.  */
11264                 tree arg_types =
11265                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11266
11267                 /* Skip the `in_chrg' argument too, if present.  */
11268                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11269                   arg_types = TREE_CHAIN (arg_types);
11270
11271                 if (arg_types == void_list_node
11272                     || (arg_types
11273                         && TREE_CHAIN (arg_types)
11274                         && TREE_CHAIN (arg_types) != void_list_node
11275                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11276                   DECL_NONCONVERTING_P (decl) = 1;
11277               }
11278           }
11279         else if (TREE_CODE (type) == METHOD_TYPE)
11280           {
11281             /* We only get here for friend declarations of
11282                members of other classes.  */
11283             /* All method decls are public, so tell grokfndecl to set
11284                TREE_PUBLIC, also.  */
11285             decl = grokfndecl (ctype, type, declarator, declarator,
11286                                virtualp, flags, quals, raises,
11287                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11288                                template_count, in_namespace);
11289             if (decl == NULL_TREE)
11290               return NULL_TREE;
11291           }
11292         else if (!staticp && ! processing_template_decl
11293                  && !COMPLETE_TYPE_P (complete_type (type))
11294                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11295           {
11296             if (declarator)
11297               cp_error ("field `%D' has incomplete type", declarator);
11298             else
11299               cp_error ("name `%T' has incomplete type", type);
11300
11301             /* If we're instantiating a template, tell them which
11302                instantiation made the field's type be incomplete.  */
11303             if (current_class_type
11304                 && TYPE_NAME (current_class_type)
11305                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11306                 && declspecs && TREE_VALUE (declspecs)
11307                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11308               cp_error ("  in instantiation of template `%T'",
11309                         current_class_type);
11310
11311             type = error_mark_node;
11312             decl = NULL_TREE;
11313           }
11314         else
11315           {
11316             if (friendp)
11317               {
11318                 error ("`%s' is neither function nor member function; cannot be declared friend",
11319                        IDENTIFIER_POINTER (declarator));
11320                 friendp = 0;
11321               }
11322             decl = NULL_TREE;
11323           }
11324
11325         if (friendp)
11326           {
11327             /* Friends are treated specially.  */
11328             if (ctype == current_class_type)
11329               warning ("member functions are implicitly friends of their class");
11330             else
11331               {
11332                 tree t = NULL_TREE;
11333                 if (decl && DECL_NAME (decl))
11334                   {
11335                     if (template_class_depth (current_class_type) == 0)
11336                       {
11337                         decl
11338                           = check_explicit_specialization
11339                           (declarator, decl,
11340                            template_count, 2 * (funcdef_flag != 0) + 4);
11341                         if (decl == error_mark_node)
11342                           return error_mark_node;
11343                       }
11344
11345                     t = do_friend (ctype, declarator, decl,
11346                                    last_function_parms, attrlist, flags, quals,
11347                                    funcdef_flag);
11348                   }
11349                 if (t && funcdef_flag)
11350                   return t;
11351
11352                 return void_type_node;
11353               }
11354           }
11355
11356         /* Structure field.  It may not be a function, except for C++ */
11357
11358         if (decl == NULL_TREE)
11359           {
11360             if (initialized)
11361               {
11362                 if (!staticp)
11363                   {
11364                     /* An attempt is being made to initialize a non-static
11365                        member.  But, from [class.mem]:
11366
11367                        4 A member-declarator can contain a
11368                        constant-initializer only if it declares a static
11369                        member (_class.static_) of integral or enumeration
11370                        type, see _class.static.data_.
11371
11372                        This used to be relatively common practice, but
11373                        the rest of the compiler does not correctly
11374                        handle the initialization unless the member is
11375                        static so we make it static below.  */
11376                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11377                                 declarator);
11378                     cp_pedwarn ("making `%D' static", declarator);
11379                     staticp = 1;
11380                   }
11381
11382                 if (uses_template_parms (type))
11383                   /* We'll check at instantiation time.  */
11384                   ;
11385                 else if (check_static_variable_definition (declarator,
11386                                                            type))
11387                   /* If we just return the declaration, crashes
11388                      will sometimes occur.  We therefore return
11389                      void_type_node, as if this was a friend
11390                      declaration, to cause callers to completely
11391                      ignore this declaration.  */
11392                   return void_type_node;
11393               }
11394
11395             /* 9.2p13 [class.mem] */
11396             if (declarator == constructor_name (current_class_type)
11397                 /* The standard does not allow non-static data members
11398                    here either, but we agreed at the 10/99 meeting
11399                    to change that in TC 1 so that they are allowed in
11400                    classes with no user-defined constructors.  */
11401                 && staticp)
11402               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11403                           declarator);
11404
11405             if (staticp)
11406               {
11407                 /* C++ allows static class members.  All other work
11408                    for this is done by grokfield.  */
11409                 decl = build_lang_decl (VAR_DECL, declarator, type);
11410                 TREE_STATIC (decl) = 1;
11411                 /* In class context, 'static' means public access.  */
11412                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11413               }
11414             else
11415               {
11416                 decl = build_decl (FIELD_DECL, declarator, type);
11417                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11418                   {
11419                     DECL_MUTABLE_P (decl) = 1;
11420                     RIDBIT_RESET (RID_MUTABLE, specbits);
11421                   }
11422               }
11423
11424             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11425                             inlinep, friendp, raises != NULL_TREE);
11426           }
11427       }
11428     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11429       {
11430         tree original_name;
11431         int publicp = 0;
11432
11433         if (! declarator)
11434           return NULL_TREE;
11435
11436         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11437           original_name = dname;
11438         else
11439           original_name = declarator;
11440
11441         if (RIDBIT_SETP (RID_AUTO, specbits))
11442           error ("storage class `auto' invalid for function `%s'", name);
11443         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11444           error ("storage class `register' invalid for function `%s'", name);
11445
11446         /* Function declaration not at top level.
11447            Storage classes other than `extern' are not allowed
11448            and `extern' makes no difference.  */
11449         if (! toplevel_bindings_p ()
11450             && (RIDBIT_SETP (RID_STATIC, specbits)
11451                 || RIDBIT_SETP (RID_INLINE, specbits))
11452             && pedantic)
11453           {
11454             if (RIDBIT_SETP (RID_STATIC, specbits))
11455               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11456             else
11457               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11458           }
11459
11460         if (ctype == NULL_TREE)
11461           {
11462             if (virtualp)
11463               {
11464                 error ("virtual non-class function `%s'", name);
11465                 virtualp = 0;
11466               }
11467           }
11468         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11469           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11470                                           TYPE_ARG_TYPES (type));
11471
11472         /* Record presence of `static'.  */
11473         publicp = (ctype != NULL_TREE
11474                    || RIDBIT_SETP (RID_EXTERN, specbits)
11475                    || !RIDBIT_SETP (RID_STATIC, specbits));
11476
11477         decl = grokfndecl (ctype, type, original_name, declarator,
11478                            virtualp, flags, quals, raises,
11479                            1, friendp,
11480                            publicp, inlinep, funcdef_flag,
11481                            template_count, in_namespace);
11482         if (decl == NULL_TREE)
11483           return NULL_TREE;
11484
11485         if (staticp == 1)
11486           {
11487             int illegal_static = 0;
11488
11489             /* Don't allow a static member function in a class, and forbid
11490                declaring main to be static.  */
11491             if (TREE_CODE (type) == METHOD_TYPE)
11492               {
11493                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11494                 illegal_static = 1;
11495               }
11496             else if (current_function_decl)
11497               {
11498                 /* FIXME need arm citation */
11499                 error ("cannot declare static function inside another function");
11500                 illegal_static = 1;
11501               }
11502
11503             if (illegal_static)
11504               {
11505                 staticp = 0;
11506                 RIDBIT_RESET (RID_STATIC, specbits);
11507               }
11508           }
11509       }
11510     else
11511       {
11512         /* It's a variable.  */
11513
11514         /* An uninitialized decl with `extern' is a reference.  */
11515         decl = grokvardecl (type, declarator, &specbits,
11516                             initialized,
11517                             (type_quals & TYPE_QUAL_CONST) != 0,
11518                             in_namespace);
11519         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11520                         inlinep, friendp, raises != NULL_TREE);
11521
11522         if (ctype)
11523           {
11524             DECL_CONTEXT (decl) = ctype;
11525             if (staticp == 1)
11526               {
11527                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11528                 staticp = 0;
11529                 RIDBIT_RESET (RID_STATIC, specbits);
11530               }
11531             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11532               {
11533                 cp_error ("static member `%D' declared `register'", decl);
11534                 RIDBIT_RESET (RID_REGISTER, specbits);
11535               }
11536             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11537               {
11538                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11539                             decl);
11540                 RIDBIT_RESET (RID_EXTERN, specbits);
11541               }
11542           }
11543       }
11544
11545     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11546
11547     /* Record `register' declaration for warnings on &
11548        and in case doing stupid register allocation.  */
11549
11550     if (RIDBIT_SETP (RID_REGISTER, specbits))
11551       DECL_REGISTER (decl) = 1;
11552
11553     if (RIDBIT_SETP (RID_EXTERN, specbits))
11554       DECL_THIS_EXTERN (decl) = 1;
11555
11556     if (RIDBIT_SETP (RID_STATIC, specbits))
11557       DECL_THIS_STATIC (decl) = 1;
11558
11559     /* Record constancy and volatility.  There's no need to do this
11560        when processing a template; we'll do this for the instantiated
11561        declaration based on the type of DECL.  */
11562     if (!processing_template_decl)
11563       c_apply_type_quals_to_decl (type_quals, decl);
11564
11565     return decl;
11566   }
11567 }
11568 \f
11569 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11570    An empty exprlist is a parmlist.  An exprlist which
11571    contains only identifiers at the global level
11572    is a parmlist.  Otherwise, it is an exprlist.  */
11573
11574 int
11575 parmlist_is_exprlist (exprs)
11576      tree exprs;
11577 {
11578   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11579     return 0;
11580
11581   if (toplevel_bindings_p ())
11582     {
11583       /* At the global level, if these are all identifiers,
11584          then it is a parmlist.  */
11585       while (exprs)
11586         {
11587           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11588             return 1;
11589           exprs = TREE_CHAIN (exprs);
11590         }
11591       return 0;
11592     }
11593   return 1;
11594 }
11595
11596 /* Subroutine of start_function.  Ensure that each of the parameter
11597    types (as listed in PARMS) is complete, as is required for a
11598    function definition.  */
11599
11600 static void
11601 require_complete_types_for_parms (parms)
11602      tree parms;
11603 {
11604   for (; parms; parms = TREE_CHAIN (parms))
11605     {
11606       tree type = TREE_TYPE (parms);
11607
11608       /* Try to complete the TYPE.  */
11609       type = complete_type (type);
11610
11611       if (type == error_mark_node)
11612         continue;
11613
11614       if (!COMPLETE_TYPE_P (type))
11615         {
11616           if (DECL_NAME (parms))
11617             error ("parameter `%s' has incomplete type",
11618                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11619           else
11620             error ("parameter has incomplete type");
11621           TREE_TYPE (parms) = error_mark_node;
11622         }
11623       else
11624         layout_decl (parms, 0);
11625     }
11626 }
11627
11628 /* Returns non-zero if T is a local variable.  */
11629
11630 int
11631 local_variable_p (t)
11632      tree t;
11633 {
11634   if ((TREE_CODE (t) == VAR_DECL
11635        /* A VAR_DECL with a context that is a _TYPE is a static data
11636           member.  */
11637        && !TYPE_P (CP_DECL_CONTEXT (t))
11638        /* Any other non-local variable must be at namespace scope.  */
11639        && !DECL_NAMESPACE_SCOPE_P (t))
11640       || (TREE_CODE (t) == PARM_DECL))
11641     return 1;
11642
11643   return 0;
11644 }
11645
11646 /* Returns non-zero if T is an automatic local variable or a label.
11647    (These are the declarations that need to be remapped when the code
11648    containing them is duplicated.)  */
11649
11650 int
11651 nonstatic_local_decl_p (t)
11652      tree t;
11653 {
11654   return ((local_variable_p (t) && !TREE_STATIC (t))
11655           || TREE_CODE (t) == LABEL_DECL
11656           || TREE_CODE (t) == RESULT_DECL);
11657 }
11658
11659 /* Like local_variable_p, but suitable for use as a tree-walking
11660    function.  */
11661
11662 static tree
11663 local_variable_p_walkfn (tp, walk_subtrees, data)
11664      tree *tp;
11665      int *walk_subtrees ATTRIBUTE_UNUSED;
11666      void *data ATTRIBUTE_UNUSED;
11667 {
11668   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11669           ? *tp : NULL_TREE);
11670 }
11671
11672 /* Check that ARG, which is a default-argument expression for a
11673    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11674    something goes wrong.  DECL may also be a _TYPE node, rather than a
11675    DECL, if there is no DECL available.  */
11676
11677 tree
11678 check_default_argument (decl, arg)
11679      tree decl;
11680      tree arg;
11681 {
11682   tree var;
11683   tree decl_type;
11684
11685   if (TREE_CODE (arg) == DEFAULT_ARG)
11686     /* We get a DEFAULT_ARG when looking at an in-class declaration
11687        with a default argument.  Ignore the argument for now; we'll
11688        deal with it after the class is complete.  */
11689     return arg;
11690
11691   if (processing_template_decl || uses_template_parms (arg))
11692     /* We don't do anything checking until instantiation-time.  Note
11693        that there may be uninstantiated arguments even for an
11694        instantiated function, since default arguments are not
11695        instantiated until they are needed.  */
11696     return arg;
11697
11698   if (TYPE_P (decl))
11699     {
11700       decl_type = decl;
11701       decl = NULL_TREE;
11702     }
11703   else
11704     decl_type = TREE_TYPE (decl);
11705
11706   if (arg == error_mark_node
11707       || decl == error_mark_node
11708       || TREE_TYPE (arg) == error_mark_node
11709       || decl_type == error_mark_node)
11710     /* Something already went wrong.  There's no need to check
11711        further.  */
11712     return error_mark_node;
11713
11714   /* [dcl.fct.default]
11715
11716      A default argument expression is implicitly converted to the
11717      parameter type.  */
11718   if (!TREE_TYPE (arg)
11719       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11720     {
11721       if (decl)
11722         cp_error ("default argument for `%#D' has type `%T'",
11723                   decl, TREE_TYPE (arg));
11724       else
11725         cp_error ("default argument for parameter of type `%T' has type `%T'",
11726                   decl_type, TREE_TYPE (arg));
11727
11728       return error_mark_node;
11729     }
11730
11731   /* [dcl.fct.default]
11732
11733      Local variables shall not be used in default argument
11734      expressions.
11735
11736      The keyword `this' shall not be used in a default argument of a
11737      member function.  */
11738   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11739   if (var)
11740     {
11741       cp_error ("default argument `%E' uses local variable `%D'",
11742                 arg, var);
11743       return error_mark_node;
11744     }
11745
11746   /* All is well.  */
11747   return arg;
11748 }
11749
11750 /* Decode the list of parameter types for a function type.
11751    Given the list of things declared inside the parens,
11752    return a list of types.
11753
11754    The list we receive can have three kinds of elements:
11755    an IDENTIFIER_NODE for names given without types,
11756    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11757    or void_type_node, to mark the end of an argument list
11758    when additional arguments are not permitted (... was not used).
11759
11760    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11761    a mere declaration.  A nonempty identifier-list gets an error message
11762    when FUNCDEF_FLAG is zero.
11763    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11764    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11765
11766    If all elements of the input list contain types,
11767    we return a list of the types.
11768    If all elements contain no type (except perhaps a void_type_node
11769    at the end), we return a null list.
11770    If some have types and some do not, it is an error, and we
11771    return a null list.
11772
11773    Also set last_function_parms to either
11774    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11775    A list of names is converted to a chain of PARM_DECLs
11776    by store_parm_decls so that ultimately it is always a chain of decls.
11777
11778    Note that in C++, parameters can take default values.  These default
11779    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11780    an error to specify default values which are followed by parameters
11781    that have no default values, or an ELLIPSES.  For simplicities sake,
11782    only parameters which are specified with their types can take on
11783    default values.  */
11784
11785 static tree
11786 grokparms (first_parm, funcdef_flag)
11787      tree first_parm;
11788      int funcdef_flag;
11789 {
11790   tree result = NULL_TREE;
11791   tree decls = NULL_TREE;
11792
11793   if (first_parm != NULL_TREE
11794       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11795     {
11796       if (! funcdef_flag)
11797         pedwarn ("parameter names (without types) in function declaration");
11798       last_function_parms = first_parm;
11799       return NULL_TREE;
11800     }
11801   else if (first_parm != NULL_TREE
11802            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11803            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11804     my_friendly_abort (145);
11805   else
11806     {
11807       /* Types were specified.  This is a list of declarators
11808          each represented as a TREE_LIST node.  */
11809       register tree parm, chain;
11810       int any_init = 0, any_error = 0;
11811
11812       if (first_parm != NULL_TREE)
11813         {
11814           tree last_result = NULL_TREE;
11815           tree last_decl = NULL_TREE;
11816
11817           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11818             {
11819               tree type = NULL_TREE, list_node = parm;
11820               register tree decl = TREE_VALUE (parm);
11821               tree init = TREE_PURPOSE (parm);
11822
11823               chain = TREE_CHAIN (parm);
11824               /* @@ weak defense against parse errors.  */
11825               if (TREE_CODE (decl) != VOID_TYPE
11826                   && TREE_CODE (decl) != TREE_LIST)
11827                 {
11828                   /* Give various messages as the need arises.  */
11829                   if (TREE_CODE (decl) == STRING_CST)
11830                     cp_error ("invalid string constant `%E'", decl);
11831                   else if (TREE_CODE (decl) == INTEGER_CST)
11832                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11833                   continue;
11834                 }
11835
11836               if (TREE_CODE (decl) != VOID_TYPE)
11837                 {
11838                   decl = grokdeclarator (TREE_VALUE (decl),
11839                                          TREE_PURPOSE (decl),
11840                                          PARM, init != NULL_TREE,
11841                                          NULL_TREE);
11842                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11843                     continue;
11844
11845                   /* Top-level qualifiers on the parameters are
11846                      ignored for function types.  */
11847                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11848
11849                   if (TREE_CODE (type) == VOID_TYPE)
11850                     decl = void_type_node;
11851                   else if (TREE_CODE (type) == METHOD_TYPE)
11852                     {
11853                       if (DECL_NAME (decl))
11854                         /* Cannot use the decl here because
11855                            we don't have DECL_CONTEXT set up yet.  */
11856                         cp_error ("parameter `%D' invalidly declared method type",
11857                                   DECL_NAME (decl));
11858                       else
11859                         error ("parameter invalidly declared method type");
11860                       type = build_pointer_type (type);
11861                       TREE_TYPE (decl) = type;
11862                     }
11863                   else if (TREE_CODE (type) == OFFSET_TYPE)
11864                     {
11865                       if (DECL_NAME (decl))
11866                         cp_error ("parameter `%D' invalidly declared offset type",
11867                                   DECL_NAME (decl));
11868                       else
11869                         error ("parameter invalidly declared offset type");
11870                       type = build_pointer_type (type);
11871                       TREE_TYPE (decl) = type;
11872                     }
11873                   else if (abstract_virtuals_error (decl, type))
11874                     any_error = 1;  /* Seems like a good idea. */
11875                   else if (POINTER_TYPE_P (type))
11876                     {
11877                       tree t = type;
11878                       while (POINTER_TYPE_P (t)
11879                              || (TREE_CODE (t) == ARRAY_TYPE
11880                                  && TYPE_DOMAIN (t) != NULL_TREE))
11881                         t = TREE_TYPE (t);
11882                       if (TREE_CODE (t) == ARRAY_TYPE)
11883                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
11884                                   type,
11885                                   TYPE_PTR_P (type) ? "pointer" : "reference");
11886                     }
11887                 }
11888
11889               if (TREE_CODE (decl) == VOID_TYPE)
11890                 {
11891                   if (result == NULL_TREE)
11892                     {
11893                       result = void_list_node;
11894                       last_result = result;
11895                     }
11896                   else
11897                     {
11898                       TREE_CHAIN (last_result) = void_list_node;
11899                       last_result = void_list_node;
11900                     }
11901                   if (chain
11902                       && (chain != void_list_node || TREE_CHAIN (chain)))
11903                     error ("`void' in parameter list must be entire list");
11904                   break;
11905                 }
11906
11907               /* Since there is a prototype, args are passed in their own types.  */
11908               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11909               if (PROMOTE_PROTOTYPES
11910                   && (TREE_CODE (type) == INTEGER_TYPE
11911                       || TREE_CODE (type) == ENUMERAL_TYPE)
11912                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11913                 DECL_ARG_TYPE (decl) = integer_type_node;
11914               if (!any_error && init)
11915                 {
11916                   any_init++;
11917                   init = check_default_argument (decl, init);
11918                 }
11919               else
11920                 init = NULL_TREE;
11921
11922               if (decls == NULL_TREE)
11923                 {
11924                   decls = decl;
11925                   last_decl = decls;
11926                 }
11927               else
11928                 {
11929                   TREE_CHAIN (last_decl) = decl;
11930                   last_decl = decl;
11931                 }
11932               list_node = tree_cons (init, type, NULL_TREE);
11933               if (result == NULL_TREE)
11934                 {
11935                   result = list_node;
11936                   last_result = result;
11937                 }
11938               else
11939                 {
11940                   TREE_CHAIN (last_result) = list_node;
11941                   last_result = list_node;
11942                 }
11943             }
11944           if (last_result)
11945             TREE_CHAIN (last_result) = NULL_TREE;
11946           /* If there are no parameters, and the function does not end
11947              with `...', then last_decl will be NULL_TREE.  */
11948           if (last_decl != NULL_TREE)
11949             TREE_CHAIN (last_decl) = NULL_TREE;
11950         }
11951     }
11952
11953   last_function_parms = decls;
11954
11955   return result;
11956 }
11957
11958 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11959    FUNCTION_TYPE with the newly parsed version of its default argument, which
11960    was previously digested as text.  See snarf_defarg et al in lex.c.  */
11961
11962 void
11963 replace_defarg (arg, init)
11964      tree arg, init;
11965 {
11966   if (! processing_template_decl
11967       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11968     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11969                 TREE_TYPE (init), TREE_VALUE (arg));
11970   TREE_PURPOSE (arg) = init;
11971 }
11972 \f
11973 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11974    D's arguments allow it to be a copy constructor, or copy assignment
11975    operator.  */
11976
11977 int
11978 copy_args_p (d)
11979      tree d;
11980 {
11981   tree t;
11982
11983   if (!DECL_FUNCTION_MEMBER_P (d))
11984     return 0;
11985
11986   t = FUNCTION_ARG_CHAIN (d);
11987   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
11988     t = TREE_CHAIN (t);
11989   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11990       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11991           == DECL_CONTEXT (d))
11992       && (TREE_CHAIN (t) == NULL_TREE
11993           || TREE_CHAIN (t) == void_list_node
11994           || TREE_PURPOSE (TREE_CHAIN (t))))
11995     return 1;
11996   return 0;
11997 }
11998
11999 /* These memoizing functions keep track of special properties which
12000    a class may have.  `grok_ctor_properties' notices whether a class
12001    has a constructor of the form X(X&), and also complains
12002    if the class has a constructor of the form X(X).
12003    `grok_op_properties' takes notice of the various forms of
12004    operator= which are defined, as well as what sorts of type conversion
12005    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12006
12007 int
12008 grok_ctor_properties (ctype, decl)
12009      tree ctype, decl;
12010 {
12011   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12012   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12013
12014   /* When a type has virtual baseclasses, a magical first int argument is
12015      added to any ctor so we can tell if the class has been initialized
12016      yet.  This could screw things up in this function, so we deliberately
12017      ignore the leading int if we're in that situation.  */
12018   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12019     {
12020       my_friendly_assert (parmtypes
12021                           && TREE_VALUE (parmtypes) == integer_type_node,
12022                           980529);
12023       parmtypes = TREE_CHAIN (parmtypes);
12024       parmtype = TREE_VALUE (parmtypes);
12025     }
12026
12027   /* [class.copy]
12028
12029      A non-template constructor for class X is a copy constructor if
12030      its first parameter is of type X&, const X&, volatile X& or const
12031      volatile X&, and either there are no other parameters or else all
12032      other parameters have default arguments.  */
12033   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12034       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12035       && (TREE_CHAIN (parmtypes) == NULL_TREE
12036           || TREE_CHAIN (parmtypes) == void_list_node
12037           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12038       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12039            && is_member_template (DECL_TI_TEMPLATE (decl))))
12040     {
12041       TYPE_HAS_INIT_REF (ctype) = 1;
12042       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12043         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12044     }
12045   /* [class.copy]
12046
12047      A declaration of a constructor for a class X is ill-formed if its
12048      first parameter is of type (optionally cv-qualified) X and either
12049      there are no other parameters or else all other parameters have
12050      default arguments.
12051
12052      We *don't* complain about member template instantiations that
12053      have this form, though; they can occur as we try to decide what
12054      constructor to use during overload resolution.  Since overload
12055      resolution will never prefer such a constructor to the
12056      non-template copy constructor (which is either explicitly or
12057      implicitly defined), there's no need to worry about their
12058      existence.  Theoretically, they should never even be
12059      instantiated, but that's hard to forestall.  */
12060   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12061            && (TREE_CHAIN (parmtypes) == NULL_TREE
12062                || TREE_CHAIN (parmtypes) == void_list_node
12063                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12064            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12065                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12066     {
12067       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12068                 ctype, ctype);
12069       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12070       return 0;
12071     }
12072   else if (TREE_CODE (parmtype) == VOID_TYPE
12073            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12074     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12075
12076   return 1;
12077 }
12078
12079 /* An operator with this name can be either unary or binary.  */
12080
12081 static int
12082 ambi_op_p (name)
12083      tree name;
12084 {
12085   return (name == ansi_opname [(int) INDIRECT_REF]
12086           || name == ansi_opname [(int) ADDR_EXPR]
12087           || name == ansi_opname [(int) NEGATE_EXPR]
12088           || name == ansi_opname[(int) POSTINCREMENT_EXPR]
12089           || name == ansi_opname[(int) POSTDECREMENT_EXPR]
12090           || name == ansi_opname [(int) CONVERT_EXPR]);
12091 }
12092
12093 /* An operator with this name can only be unary.  */
12094
12095 static int
12096 unary_op_p (name)
12097      tree name;
12098 {
12099   return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
12100           || name == ansi_opname [(int) BIT_NOT_EXPR]
12101           || name == ansi_opname [(int) COMPONENT_REF]
12102           || IDENTIFIER_TYPENAME_P (name));
12103 }
12104
12105 /* Do a little sanity-checking on how they declared their operator.  */
12106
12107 void
12108 grok_op_properties (decl, virtualp, friendp)
12109      tree decl;
12110      int virtualp, friendp;
12111 {
12112   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12113   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12114   tree name = DECL_NAME (decl);
12115
12116   if (current_class_type == NULL_TREE)
12117     friendp = 1;
12118
12119   if (! friendp)
12120     {
12121       /* [class.copy]
12122
12123          A user-declared copy assignment operator X::operator= is a
12124          non-static non-template member function of class X with
12125          exactly one parameter of type X, X&, const X&, volatile X& or
12126          const volatile X&.  */
12127       if (name == ansi_opname[(int) MODIFY_EXPR]
12128           && !(DECL_TEMPLATE_INSTANTIATION (decl)
12129                && is_member_template (DECL_TI_TEMPLATE (decl))))
12130         ;
12131       else if (name == ansi_opname[(int) CALL_EXPR])
12132         TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12133       else if (name == ansi_opname[(int) ARRAY_REF])
12134         TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12135       else if (name == ansi_opname[(int) COMPONENT_REF]
12136                || name == ansi_opname[(int) MEMBER_REF])
12137         TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12138       else if (name == ansi_opname[(int) NEW_EXPR])
12139         TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12140       else if (name == ansi_opname[(int) DELETE_EXPR])
12141         TYPE_GETS_DELETE (current_class_type) |= 1;
12142       else if (name == ansi_opname[(int) VEC_NEW_EXPR])
12143         TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12144       else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
12145         TYPE_GETS_DELETE (current_class_type) |= 2;
12146     }
12147
12148   if (name == ansi_opname[(int) NEW_EXPR]
12149       || name == ansi_opname[(int) VEC_NEW_EXPR])
12150     {
12151       /* When the compiler encounters the definition of A::operator new, it
12152          doesn't look at the class declaration to find out if it's static.  */
12153       if (methodp)
12154         revert_static_member_fn (decl);
12155
12156       /* Take care of function decl if we had syntax errors.  */
12157       if (argtypes == NULL_TREE)
12158         TREE_TYPE (decl)
12159           = build_function_type (ptr_type_node,
12160                                  hash_tree_chain (integer_type_node,
12161                                                   void_list_node));
12162       else
12163         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12164     }
12165   else if (name == ansi_opname[(int) DELETE_EXPR]
12166            || name == ansi_opname[(int) VEC_DELETE_EXPR])
12167     {
12168       if (methodp)
12169         revert_static_member_fn (decl);
12170
12171       if (argtypes == NULL_TREE)
12172         TREE_TYPE (decl)
12173           = build_function_type (void_type_node,
12174                                  hash_tree_chain (ptr_type_node,
12175                                                   void_list_node));
12176       else
12177         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12178     }
12179   else
12180     {
12181       /* An operator function must either be a non-static member function
12182          or have at least one parameter of a class, a reference to a class,
12183          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12184       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12185         {
12186           if (DECL_CONV_FN_P (decl)
12187               || name == ansi_opname[(int) CALL_EXPR]
12188               || name == ansi_opname[(int) MODIFY_EXPR]
12189               || name == ansi_opname[(int) COMPONENT_REF]
12190               || name == ansi_opname[(int) ARRAY_REF])
12191             cp_error ("`%D' must be a nonstatic member function", decl);
12192           else
12193             {
12194               tree p = argtypes;
12195
12196               if (DECL_STATIC_FUNCTION_P (decl))
12197                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12198
12199               if (p)
12200                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12201                   {
12202                     tree arg = TREE_VALUE (p);
12203                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12204                       arg = TREE_TYPE (arg);
12205
12206                     /* This lets bad template code slip through.  */
12207                     if (IS_AGGR_TYPE (arg)
12208                         || TREE_CODE (arg) == ENUMERAL_TYPE
12209                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12210                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12211                       goto foundaggr;
12212                   }
12213               cp_error
12214                 ("`%D' must have an argument of class or enumerated type",
12215                  decl);
12216             foundaggr:
12217               ;
12218             }
12219         }
12220
12221       if (name == ansi_opname[(int) CALL_EXPR])
12222         return;                 /* No restrictions on args. */
12223
12224       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12225         {
12226           tree t = TREE_TYPE (name);
12227           if (! friendp)
12228             {
12229               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12230               const char *what = 0;
12231
12232               if (ref)
12233                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12234
12235               if (TREE_CODE (t) == VOID_TYPE)
12236                 what = "void";
12237               else if (t == current_class_type)
12238                 what = "the same type";
12239               /* Don't force t to be complete here.  */
12240               else if (IS_AGGR_TYPE (t)
12241                        && COMPLETE_TYPE_P (t)
12242                        && DERIVED_FROM_P (t, current_class_type))
12243                 what = "a base class";
12244
12245               if (what)
12246                 warning ("conversion to %s%s will never use a type conversion operator",
12247                          ref ? "a reference to " : "", what);
12248             }
12249         }
12250
12251       if (name == ansi_opname[(int) MODIFY_EXPR])
12252         {
12253           tree parmtype;
12254
12255           if (list_length (argtypes) != 3 && methodp)
12256             {
12257               cp_error ("`%D' must take exactly one argument", decl);
12258               return;
12259             }
12260           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12261
12262           if (copy_assignment_arg_p (parmtype, virtualp)
12263               && ! friendp)
12264             {
12265               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12266               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12267                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12268                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12269             }
12270         }
12271       else if (name == ansi_opname[(int) COND_EXPR])
12272         {
12273           /* 13.4.0.3 */
12274           cp_error ("ISO C++ prohibits overloading operator ?:");
12275         }
12276       else if (ambi_op_p (name))
12277         {
12278           if (list_length (argtypes) == 2)
12279             /* prefix */;
12280           else if (list_length (argtypes) == 3)
12281             {
12282               if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
12283                    || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12284                   && ! processing_template_decl
12285                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12286                 {
12287                   if (methodp)
12288                     cp_error ("postfix `%D' must take `int' as its argument",
12289                               decl);
12290                   else
12291                     cp_error
12292                       ("postfix `%D' must take `int' as its second argument",
12293                        decl);
12294                 }
12295             }
12296           else
12297             {
12298               if (methodp)
12299                 cp_error ("`%D' must take either zero or one argument", decl);
12300               else
12301                 cp_error ("`%D' must take either one or two arguments", decl);
12302             }
12303
12304           /* More Effective C++ rule 6.  */
12305           if (warn_ecpp
12306               && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12307                   || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
12308             {
12309               tree arg = TREE_VALUE (argtypes);
12310               tree ret = TREE_TYPE (TREE_TYPE (decl));
12311               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12312                 arg = TREE_TYPE (arg);
12313               arg = TYPE_MAIN_VARIANT (arg);
12314               if (list_length (argtypes) == 2)
12315                 {
12316                   if (TREE_CODE (ret) != REFERENCE_TYPE
12317                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12318                                        arg))
12319                     cp_warning ("prefix `%D' should return `%T'", decl,
12320                                 build_reference_type (arg));
12321                 }
12322               else
12323                 {
12324                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12325                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12326                 }
12327             }
12328         }
12329       else if (unary_op_p (name))
12330         {
12331           if (list_length (argtypes) != 2)
12332             {
12333               if (methodp)
12334                 cp_error ("`%D' must take `void'", decl);
12335               else
12336                 cp_error ("`%D' must take exactly one argument", decl);
12337             }
12338         }
12339       else /* if (binary_op_p (name)) */
12340         {
12341           if (list_length (argtypes) != 3)
12342             {
12343               if (methodp)
12344                 cp_error ("`%D' must take exactly one argument", decl);
12345               else
12346                 cp_error ("`%D' must take exactly two arguments", decl);
12347             }
12348
12349           /* More Effective C++ rule 7.  */
12350           if (warn_ecpp
12351               && (name == ansi_opname [TRUTH_ANDIF_EXPR]
12352                   || name == ansi_opname [TRUTH_ORIF_EXPR]
12353                   || name == ansi_opname [COMPOUND_EXPR]))
12354             cp_warning ("user-defined `%D' always evaluates both arguments",
12355                         decl);
12356         }
12357
12358       /* Effective C++ rule 23.  */
12359       if (warn_ecpp
12360           && list_length (argtypes) == 3
12361           && (name == ansi_opname [PLUS_EXPR]
12362               || name == ansi_opname [MINUS_EXPR]
12363               || name == ansi_opname [TRUNC_DIV_EXPR]
12364               || name == ansi_opname [MULT_EXPR])
12365           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12366         cp_warning ("`%D' should return by value", decl);
12367
12368       /* 13.4.0.8 */
12369       for (; argtypes && argtypes != void_list_node;
12370           argtypes = TREE_CHAIN (argtypes))
12371         if (TREE_PURPOSE (argtypes))
12372           {
12373             TREE_PURPOSE (argtypes) = NULL_TREE;
12374             if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12375                 || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12376               {
12377                 if (pedantic)
12378                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12379               }
12380             else
12381               cp_error ("`%D' cannot have default arguments", decl);
12382           }
12383
12384     }
12385 }
12386 \f
12387 static const char *
12388 tag_name (code)
12389      enum tag_types code;
12390 {
12391   switch (code)
12392     {
12393     case record_type:
12394       return "struct";
12395     case class_type:
12396       return "class";
12397     case union_type:
12398       return "union ";
12399     case enum_type:
12400       return "enum";
12401     default:
12402       my_friendly_abort (981122);
12403     }
12404 }
12405
12406 /* Get the struct, enum or union (CODE says which) with tag NAME.
12407    Define the tag as a forward-reference if it is not defined.
12408
12409    C++: If a class derivation is given, process it here, and report
12410    an error if multiple derivation declarations are not identical.
12411
12412    If this is a definition, come in through xref_tag and only look in
12413    the current frame for the name (since C++ allows new names in any
12414    scope.)  */
12415
12416 tree
12417 xref_tag (code_type_node, name, globalize)
12418      tree code_type_node;
12419      tree name;
12420      int globalize;
12421 {
12422   enum tag_types tag_code;
12423   enum tree_code code;
12424   register tree ref, t;
12425   struct binding_level *b = current_binding_level;
12426   int got_type = 0;
12427   tree attributes = NULL_TREE;
12428   tree context = NULL_TREE;
12429
12430   /* If we are called from the parser, code_type_node will sometimes be a
12431      TREE_LIST.  This indicates that the user wrote
12432      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12433      use them later.  */
12434   if (TREE_CODE (code_type_node) == TREE_LIST)
12435     {
12436       attributes = TREE_PURPOSE (code_type_node);
12437       code_type_node = TREE_VALUE (code_type_node);
12438     }
12439
12440   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12441   switch (tag_code)
12442     {
12443     case record_type:
12444     case class_type:
12445       code = RECORD_TYPE;
12446       break;
12447     case union_type:
12448       code = UNION_TYPE;
12449       break;
12450     case enum_type:
12451       code = ENUMERAL_TYPE;
12452       break;
12453     default:
12454       my_friendly_abort (18);
12455     }
12456
12457   /* If a cross reference is requested, look up the type
12458      already defined for this tag and return it.  */
12459   if (TYPE_P (name))
12460     {
12461       t = name;
12462       name = TYPE_IDENTIFIER (t);
12463       got_type = 1;
12464     }
12465   else
12466     t = IDENTIFIER_TYPE_VALUE (name);
12467
12468   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12469       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12470     t = NULL_TREE;
12471
12472   if (! globalize)
12473     {
12474       /* If we know we are defining this tag, only look it up in
12475          this scope and don't try to find it as a type.  */
12476       ref = lookup_tag (code, name, b, 1);
12477     }
12478   else
12479     {
12480       if (t)
12481         {
12482           /* [dcl.type.elab] If the identifier resolves to a
12483              typedef-name or a template type-parameter, the
12484              elaborated-type-specifier is ill-formed.  */
12485           if (t != TYPE_MAIN_VARIANT (t)
12486               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12487             cp_pedwarn ("using typedef-name `%D' after `%s'",
12488                         TYPE_NAME (t), tag_name (tag_code));
12489           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12490             cp_error ("using template type parameter `%T' after `%s'",
12491                       t, tag_name (tag_code));
12492
12493           ref = t;
12494         }
12495       else
12496         ref = lookup_tag (code, name, b, 0);
12497
12498       if (! ref)
12499         {
12500           /* Try finding it as a type declaration.  If that wins,
12501              use it.  */
12502           ref = lookup_name (name, 1);
12503
12504           if (ref != NULL_TREE
12505               && processing_template_decl
12506               && DECL_CLASS_TEMPLATE_P (ref)
12507               && template_class_depth (current_class_type) == 0)
12508             /* Since GLOBALIZE is true, we're declaring a global
12509                template, so we want this type.  */
12510             ref = DECL_TEMPLATE_RESULT (ref);
12511
12512           if (ref && TREE_CODE (ref) == TYPE_DECL
12513               && TREE_CODE (TREE_TYPE (ref)) == code)
12514             ref = TREE_TYPE (ref);
12515           else
12516             ref = NULL_TREE;
12517         }
12518
12519       if (ref && current_class_type
12520           && template_class_depth (current_class_type)
12521           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12522         {
12523           /* Since GLOBALIZE is non-zero, we are not looking at a
12524              definition of this tag.  Since, in addition, we are currently
12525              processing a (member) template declaration of a template
12526              class, we must be very careful; consider:
12527
12528                template <class X>
12529                struct S1
12530
12531                template <class U>
12532                struct S2
12533                { template <class V>
12534                friend struct S1; };
12535
12536              Here, the S2::S1 declaration should not be confused with the
12537              outer declaration.  In particular, the inner version should
12538              have a template parameter of level 2, not level 1.  This
12539              would be particularly important if the member declaration
12540              were instead:
12541
12542                template <class V = U> friend struct S1;
12543
12544              say, when we should tsubst into `U' when instantiating
12545              S2.  On the other hand, when presented with:
12546
12547                  template <class T>
12548                  struct S1 {
12549                    template <class U>
12550                    struct S2 {};
12551                    template <class U>
12552                    friend struct S2;
12553                  };
12554
12555               we must find the inner binding eventually.  We
12556               accomplish this by making sure that the new type we
12557               create to represent this declaration has the right
12558               TYPE_CONTEXT.  */
12559           context = TYPE_CONTEXT (ref);
12560           ref = NULL_TREE;
12561         }
12562     }
12563
12564   if (! ref)
12565     {
12566       /* If no such tag is yet defined, create a forward-reference node
12567          and record it as the "definition".
12568          When a real declaration of this type is found,
12569          the forward-reference will be altered into a real type.  */
12570       if (code == ENUMERAL_TYPE)
12571         {
12572           cp_error ("use of enum `%#D' without previous declaration", name);
12573
12574           ref = make_node (ENUMERAL_TYPE);
12575
12576           /* Give the type a default layout like unsigned int
12577              to avoid crashing if it does not get defined.  */
12578           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12579           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12580           TREE_UNSIGNED (ref) = 1;
12581           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12582           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12583           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12584
12585           /* Enable us to recognize when a type is created in class context.
12586              To do nested classes correctly, this should probably be cleared
12587              out when we leave this classes scope.  Currently this in only
12588              done in `start_enum'.  */
12589
12590           pushtag (name, ref, globalize);
12591         }
12592       else
12593         {
12594           struct binding_level *old_b = class_binding_level;
12595
12596           ref = make_aggr_type (code);
12597           TYPE_CONTEXT (ref) = context;
12598
12599 #ifdef NONNESTED_CLASSES
12600           /* Class types don't nest the way enums do.  */
12601           class_binding_level = (struct binding_level *)0;
12602 #endif
12603           pushtag (name, ref, globalize);
12604           class_binding_level = old_b;
12605         }
12606     }
12607   else
12608     {
12609       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12610         redeclare_class_template (ref, current_template_parms);
12611     }
12612
12613   /* Until the type is defined, tentatively accept whatever
12614      structure tag the user hands us.  */
12615   if (!COMPLETE_TYPE_P (ref)
12616       && ref != current_class_type
12617       /* Have to check this, in case we have contradictory tag info.  */
12618       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12619     {
12620       if (tag_code == class_type)
12621         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12622       else if (tag_code == record_type)
12623         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12624     }
12625
12626   TREE_TYPE (ref) = attributes;
12627
12628   return ref;
12629 }
12630
12631 tree
12632 xref_tag_from_type (old, id, globalize)
12633      tree old, id;
12634      int globalize;
12635 {
12636   tree code_type_node;
12637
12638   if (TREE_CODE (old) == RECORD_TYPE)
12639     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12640                       ? class_type_node : record_type_node);
12641   else
12642     code_type_node = union_type_node;
12643
12644   if (id == NULL_TREE)
12645     id = TYPE_IDENTIFIER (old);
12646
12647   return xref_tag (code_type_node, id, globalize);
12648 }
12649
12650 /* REF is a type (named NAME), for which we have just seen some
12651    baseclasses.  BINFO is a list of those baseclasses; the
12652    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12653    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12654    struct, or union.  */
12655
12656 void
12657 xref_basetypes (code_type_node, name, ref, binfo)
12658      tree code_type_node;
12659      tree name, ref;
12660      tree binfo;
12661 {
12662   /* In the declaration `A : X, Y, ... Z' we mark all the types
12663      (A, X, Y, ..., Z) so we can check for duplicates.  */
12664   tree binfos;
12665   tree base;
12666
12667   int i, len;
12668   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12669
12670   if (tag_code == union_type)
12671     {
12672       cp_error ("derived union `%T' invalid", ref);
12673       return;
12674     }
12675
12676   len = list_length (binfo);
12677
12678   /* First, make sure that any templates in base-classes are
12679      instantiated.  This ensures that if we call ourselves recursively
12680      we do not get confused about which classes are marked and which
12681      are not.  */
12682   for (base = binfo; base; base = TREE_CHAIN (base))
12683     complete_type (TREE_VALUE (base));
12684
12685   SET_CLASSTYPE_MARKED (ref);
12686   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12687
12688   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12689     {
12690       /* The base of a derived struct is public by default.  */
12691       int via_public
12692         = (TREE_PURPOSE (binfo) == access_public_node
12693            || TREE_PURPOSE (binfo) == access_public_virtual_node
12694            || (tag_code != class_type
12695                && (TREE_PURPOSE (binfo) == access_default_node
12696                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12697       int via_protected
12698         = (TREE_PURPOSE (binfo) == access_protected_node
12699            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12700       int via_virtual
12701         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12702            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12703            || TREE_PURPOSE (binfo) == access_public_virtual_node
12704            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12705       tree basetype = TREE_VALUE (binfo);
12706       tree base_binfo;
12707
12708       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12709         basetype = TREE_TYPE (basetype);
12710       if (!basetype
12711           || (TREE_CODE (basetype) != RECORD_TYPE
12712               && TREE_CODE (basetype) != TYPENAME_TYPE
12713               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12714               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12715         {
12716           cp_error ("base type `%T' fails to be a struct or class type",
12717                     TREE_VALUE (binfo));
12718           continue;
12719         }
12720
12721       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12722
12723       /* This code replaces similar code in layout_basetypes.
12724          We put the complete_type first for implicit `typename'.  */
12725       if (!COMPLETE_TYPE_P (basetype)
12726           && ! (current_template_parms && uses_template_parms (basetype)))
12727         {
12728           cp_error ("base class `%T' has incomplete type", basetype);
12729           continue;
12730         }
12731       else
12732         {
12733           if (CLASSTYPE_MARKED (basetype))
12734             {
12735               if (basetype == ref)
12736                 cp_error ("recursive type `%T' undefined", basetype);
12737               else
12738                 cp_error ("duplicate base type `%T' invalid", basetype);
12739               continue;
12740             }
12741
12742           if (TYPE_FOR_JAVA (basetype)
12743               && (current_lang_stack
12744                   == &VARRAY_TREE (current_lang_base, 0)))
12745             TYPE_FOR_JAVA (ref) = 1;
12746
12747           /* Note that the BINFO records which describe individual
12748              inheritances are *not* shared in the lattice!  They
12749              cannot be shared because a given baseclass may be
12750              inherited with different `accessibility' by different
12751              derived classes.  (Each BINFO record describing an
12752              individual inheritance contains flags which say what
12753              the `accessibility' of that particular inheritance is.)  */
12754
12755           base_binfo
12756             = make_binfo (size_zero_node, basetype,
12757                           CLASS_TYPE_P (basetype)
12758                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12759                           CLASS_TYPE_P (basetype)
12760                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12761
12762           TREE_VEC_ELT (binfos, i) = base_binfo;
12763           TREE_VIA_PUBLIC (base_binfo) = via_public;
12764           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12765           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12766           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12767
12768           /* We need to unshare the binfos now so that lookups during class
12769              definition work.  */
12770           unshare_base_binfos (base_binfo);
12771
12772           SET_CLASSTYPE_MARKED (basetype);
12773
12774           /* We are free to modify these bits because they are meaningless
12775              at top level, and BASETYPE is a top-level type.  */
12776           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12777             {
12778               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12779               /* Converting to a virtual base class requires looking
12780                  up the offset of the virtual base.  */
12781               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12782             }
12783
12784           if (CLASS_TYPE_P (basetype))
12785             {
12786               TYPE_HAS_NEW_OPERATOR (ref)
12787                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12788               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12789                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12790               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12791               /* If the base-class uses multiple inheritance, so do we.  */
12792               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12793                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12794               /* Likewise, if converting to a base of the base may require
12795                  code, then we may need to generate code to convert to a
12796                  base as well.  */
12797               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12798                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12799             }
12800
12801           i += 1;
12802         }
12803     }
12804   if (i)
12805     TREE_VEC_LENGTH (binfos) = i;
12806   else
12807     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12808
12809   if (i > 1)
12810     {
12811       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12812       /* If there is more than one non-empty they cannot be at the same
12813          address.  */
12814       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12815     }
12816
12817   /* Unmark all the types.  */
12818   while (--i >= 0)
12819     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12820   CLEAR_CLASSTYPE_MARKED (ref);
12821
12822   /* Now that we know all the base-classes, set up the list of virtual
12823      bases.  */
12824   get_vbase_types (ref);
12825 }
12826
12827 \f
12828 /* Begin compiling the definition of an enumeration type.
12829    NAME is its name (or null if anonymous).
12830    Returns the type object, as yet incomplete.
12831    Also records info about it so that build_enumerator
12832    may be used to declare the individual values as they are read.  */
12833
12834 tree
12835 start_enum (name)
12836      tree name;
12837 {
12838   register tree enumtype = NULL_TREE;
12839   struct binding_level *b = current_binding_level;
12840
12841   /* If this is the real definition for a previous forward reference,
12842      fill in the contents in the same object that used to be the
12843      forward reference.  */
12844
12845   if (name != NULL_TREE)
12846     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12847
12848   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12849     {
12850       cp_error ("multiple definition of `%#T'", enumtype);
12851       cp_error_at ("previous definition here", enumtype);
12852       /* Clear out TYPE_VALUES, and start again.  */
12853       TYPE_VALUES (enumtype) = NULL_TREE;
12854     }
12855   else
12856     {
12857       enumtype = make_node (ENUMERAL_TYPE);
12858       pushtag (name, enumtype, 0);
12859     }
12860
12861   if (current_class_type)
12862     TREE_ADDRESSABLE (b->tags) = 1;
12863
12864   GNU_xref_decl (current_function_decl, enumtype);
12865   return enumtype;
12866 }
12867
12868 /* After processing and defining all the values of an enumeration type,
12869    install their decls in the enumeration type and finish it off.
12870    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12871    Returns ENUMTYPE.  */
12872
12873 tree
12874 finish_enum (enumtype)
12875      tree enumtype;
12876 {
12877   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12878   /* Calculate the maximum value of any enumerator in this type.  */
12879
12880   tree values = TYPE_VALUES (enumtype);
12881   if (values)
12882     {
12883       tree pair;
12884
12885       for (pair = values; pair; pair = TREE_CHAIN (pair))
12886         {
12887           tree decl;
12888           tree value;
12889
12890           /* The TREE_VALUE is a CONST_DECL for this enumeration
12891              constant.  */
12892           decl = TREE_VALUE (pair);
12893
12894           /* [dcl.enum]
12895
12896              Following the closing brace of an enum-specifier, each
12897              enumerator has the type of its enumeration.  Prior to the
12898              closing brace, the type of each enumerator is the type of
12899              its initializing value.  */
12900           TREE_TYPE (decl) = enumtype;
12901
12902           /* The DECL_INITIAL will be NULL if we are processing a
12903              template declaration and this enumeration constant had no
12904              explicit initializer.  */
12905           value = DECL_INITIAL (decl);
12906           if (value && !processing_template_decl)
12907             {
12908               /* Set the TREE_TYPE for the VALUE as well.  That's so
12909                  that when we call decl_constant_value we get an
12910                  entity of the right type (but with the constant
12911                  value).  Since we shouldn't ever call
12912                  decl_constant_value on a template type, there's no
12913                  reason to do that when processing_template_decl.
12914                  And, if the expression is something like a
12915                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12916                  wreak havoc on the intended type of the expression.
12917
12918                  Of course, there's also no point in trying to compute
12919                  minimum or maximum values if we're in a template.  */
12920               TREE_TYPE (value) = enumtype;
12921
12922               if (!minnode)
12923                 minnode = maxnode = value;
12924               else if (tree_int_cst_lt (maxnode, value))
12925                 maxnode = value;
12926               else if (tree_int_cst_lt (value, minnode))
12927                 minnode = value;
12928             }
12929
12930           if (processing_template_decl)
12931             /* If this is just a template, leave the CONST_DECL
12932                alone.  That way tsubst_copy will find CONST_DECLs for
12933                CONST_DECLs, and not INTEGER_CSTs.  */
12934             ;
12935           else
12936             /* In the list we're building up, we want the enumeration
12937                values, not the CONST_DECLs.  */
12938             TREE_VALUE (pair) = value;
12939         }
12940     }
12941   else
12942     maxnode = minnode = integer_zero_node;
12943
12944   TYPE_VALUES (enumtype) = nreverse (values);
12945
12946   if (processing_template_decl)
12947     {
12948       tree scope = current_scope ();
12949       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12950         add_tree (build_min (TAG_DEFN, enumtype));
12951     }
12952   else
12953     {
12954       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12955       int lowprec = min_precision (minnode, unsignedp);
12956       int highprec = min_precision (maxnode, unsignedp);
12957       int precision = MAX (lowprec, highprec);
12958       tree tem;
12959
12960       TYPE_SIZE (enumtype) = NULL_TREE;
12961
12962       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12963
12964       TYPE_PRECISION (enumtype) = precision;
12965       if (unsignedp)
12966         fixup_unsigned_type (enumtype);
12967       else
12968         fixup_signed_type (enumtype);
12969
12970       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12971         /* Use the width of the narrowest normal C type which is wide
12972            enough.  */
12973         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12974                                                     (precision, 1));
12975       else
12976         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12977
12978       TYPE_SIZE (enumtype) = 0;
12979       layout_type (enumtype);
12980
12981       /* Fix up all variant types of this enum type.  */
12982       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12983            tem = TYPE_NEXT_VARIANT (tem))
12984         {
12985           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12986           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12987           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12988           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12989           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12990           TYPE_MODE (tem) = TYPE_MODE (enumtype);
12991           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12992           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12993           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12994         }
12995
12996       /* Finish debugging output for this type.  */
12997       rest_of_type_compilation (enumtype, namespace_bindings_p ());
12998     }
12999
13000   return enumtype;
13001 }
13002
13003 /* Build and install a CONST_DECL for an enumeration constant of the
13004    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13005    Assignment of sequential values by default is handled here.  */
13006
13007 void
13008 build_enumerator (name, value, enumtype)
13009      tree name;
13010      tree value;
13011      tree enumtype;
13012 {
13013   tree decl;
13014   tree context;
13015   tree type;
13016   tree values;
13017
13018   /* Remove no-op casts from the value.  */
13019   if (value)
13020     STRIP_TYPE_NOPS (value);
13021
13022   if (! processing_template_decl)
13023     {
13024       /* Validate and default VALUE.  */
13025       if (value != NULL_TREE)
13026         {
13027           value = decl_constant_value (value);
13028
13029           if (TREE_CODE (value) == INTEGER_CST)
13030             {
13031               value = default_conversion (value);
13032               constant_expression_warning (value);
13033             }
13034           else
13035             {
13036               cp_error ("enumerator value for `%D' not integer constant", name);
13037               value = NULL_TREE;
13038             }
13039         }
13040
13041       /* Default based on previous value.  */
13042       if (value == NULL_TREE && ! processing_template_decl)
13043         {
13044           tree prev_value;
13045
13046           if (TYPE_VALUES (enumtype))
13047             {
13048               /* The next value is the previous value ... */
13049               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13050               /* ... plus one.  */
13051               value = build_binary_op (PLUS_EXPR,
13052                                        prev_value,
13053                                        integer_one_node);
13054
13055               if (tree_int_cst_lt (value, prev_value))
13056                 cp_error ("overflow in enumeration values at `%D'", name);
13057             }
13058           else
13059             value = integer_zero_node;
13060         }
13061
13062       /* Remove no-op casts from the value.  */
13063       if (value)
13064         STRIP_TYPE_NOPS (value);
13065 #if 0
13066       /* To fix MAX_VAL enum consts. (bkoz)  */
13067       TREE_TYPE (value) = integer_type_node;
13068 #endif
13069     }
13070
13071   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13072      Even in other cases, we will later (in finish_enum) be setting
13073      the type of VALUE.  But, we don't need to make a copy if this
13074      VALUE is one of the enumeration constants for this same
13075      enumeration type.  */
13076   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13077     if (TREE_VALUE (values) == value)
13078       break;
13079   /* If we didn't break out of the loop, then we do need a copy.  */
13080   if (!values && value)
13081     value = copy_node (value);
13082
13083   /* C++ associates enums with global, function, or class declarations.  */
13084   context = current_scope ();
13085
13086   /* Build the actual enumeration constant.  Note that the enumeration
13087     constants have the type of their initializers until the
13088     enumeration is complete:
13089
13090       [ dcl.enum ]
13091
13092       Following the closing brace of an enum-specifier, each enumer-
13093       ator has the type of its enumeration.  Prior to the closing
13094       brace, the type of each enumerator is the type of its
13095       initializing value.
13096
13097     In finish_enum we will reset the type.  Of course, if we're
13098     processing a template, there may be no value.   */
13099   type = value ? TREE_TYPE (value) : NULL_TREE;
13100
13101   if (context && context == current_class_type)
13102     /* This enum declaration is local to the class.  We need the full
13103       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13104     decl = build_lang_decl (CONST_DECL, name, type);
13105   else
13106     /* It's a global enum, or it's local to a function.  (Note local to
13107       a function could mean local to a class method.  */
13108     decl = build_decl (CONST_DECL, name, type);
13109
13110   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13111   DECL_INITIAL (decl) = value;
13112   TREE_READONLY (decl) = 1;
13113
13114   if (context && context == current_class_type)
13115     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13116       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13117       things like `S::i' later.)  */
13118     finish_member_declaration (decl);
13119   else
13120     {
13121       pushdecl (decl);
13122       GNU_xref_decl (current_function_decl, decl);
13123     }
13124
13125   /* Add this enumeration constant to the list for this type.  */
13126   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13127 }
13128
13129 \f
13130 static int function_depth;
13131
13132 /* We're defining DECL.  Make sure that it's type is OK.  */
13133
13134 static void
13135 check_function_type (decl)
13136      tree decl;
13137 {
13138   tree fntype = TREE_TYPE (decl);
13139   tree return_type = complete_type (TREE_TYPE (fntype));
13140
13141   /* In a function definition, arg types must be complete.  */
13142   require_complete_types_for_parms (current_function_parms);
13143
13144   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13145     {
13146       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13147
13148       /* Make it return void instead, but don't change the
13149          type of the DECL_RESULT, in case we have a named return value.  */
13150       if (TREE_CODE (fntype) == METHOD_TYPE)
13151         {
13152           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13153           TREE_TYPE (decl)
13154             = build_cplus_method_type (ctype,
13155                                        void_type_node,
13156                                        FUNCTION_ARG_CHAIN (decl));
13157         }
13158       else
13159         TREE_TYPE (decl)
13160           = build_function_type (void_type_node,
13161                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13162       TREE_TYPE (decl)
13163         = build_exception_variant (fntype,
13164                                    TYPE_RAISES_EXCEPTIONS (fntype));
13165     }
13166   else
13167     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13168 }
13169
13170 /* Create the FUNCTION_DECL for a function definition.
13171    DECLSPECS and DECLARATOR are the parts of the declaration;
13172    they describe the function's name and the type it returns,
13173    but twisted together in a fashion that parallels the syntax of C.
13174
13175    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13176    DECLARATOR is really the DECL for the function we are about to
13177    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13178    indicating that the function is an inline defined in-class, and
13179    SF_EXPAND indicating that we should generate RTL for this
13180    function.
13181
13182    This function creates a binding context for the function body
13183    as well as setting up the FUNCTION_DECL in current_function_decl.
13184
13185    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13186    (it defines a datum instead), we return 0, which tells
13187    yyparse to report a parse error.
13188
13189    For C++, we must first check whether that datum makes any sense.
13190    For example, "class A local_a(1,2);" means that variable local_a
13191    is an aggregate of type A, which should have a constructor
13192    applied to it with the argument list [1, 2].  */
13193
13194 int
13195 start_function (declspecs, declarator, attrs, flags)
13196      tree declspecs, declarator, attrs;
13197      int flags;
13198 {
13199   tree decl1;
13200   tree ctype = NULL_TREE;
13201   tree fntype;
13202   tree restype;
13203   extern int have_extern_spec;
13204   extern int used_extern_spec;
13205   int doing_friend = 0;
13206   struct binding_level *bl;
13207
13208   /* Sanity check.  */
13209   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13210   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13211
13212   /* This should only be done once on the top most decl.  */
13213   if (have_extern_spec && !used_extern_spec)
13214     {
13215       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13216       used_extern_spec = 1;
13217     }
13218
13219   if (flags & SF_PRE_PARSED)
13220     {
13221       decl1 = declarator;
13222
13223       fntype = TREE_TYPE (decl1);
13224       if (TREE_CODE (fntype) == METHOD_TYPE)
13225         ctype = TYPE_METHOD_BASETYPE (fntype);
13226
13227       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13228          the (lexical) scope of the class in which it is defined.  */
13229       if (!ctype && DECL_FRIEND_P (decl1))
13230         {
13231           ctype = DECL_FRIEND_CONTEXT (decl1);
13232
13233           /* CTYPE could be null here if we're dealing with a template;
13234              for example, `inline friend float foo()' inside a template
13235              will have no CTYPE set.  */
13236           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13237             ctype = NULL_TREE;
13238           else
13239             doing_friend = 1;
13240         }
13241
13242       last_function_parms = DECL_ARGUMENTS (decl1);
13243       last_function_parm_tags = NULL_TREE;
13244     }
13245   else
13246     {
13247       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13248       /* If the declarator is not suitable for a function definition,
13249          cause a syntax error.  */
13250       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13251
13252       fntype = TREE_TYPE (decl1);
13253
13254       restype = TREE_TYPE (fntype);
13255       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13256         {
13257           cp_error ("semicolon missing after declaration of `%#T'", restype);
13258           shadow_tag (build_tree_list (NULL_TREE, restype));
13259           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13260           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13261             fntype = build_function_type (integer_type_node,
13262                                           TYPE_ARG_TYPES (fntype));
13263           else
13264             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13265                                               integer_type_node,
13266                                               TYPE_ARG_TYPES (fntype));
13267           TREE_TYPE (decl1) = fntype;
13268         }
13269
13270       if (TREE_CODE (fntype) == METHOD_TYPE)
13271         ctype = TYPE_METHOD_BASETYPE (fntype);
13272       else if (DECL_MAIN_P (decl1))
13273         {
13274           /* If this doesn't return integer_type, complain.  */
13275           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13276             {
13277               if (pedantic || warn_return_type)
13278                 pedwarn ("return type for `main' changed to `int'");
13279               TREE_TYPE (decl1) = fntype = default_function_type;
13280             }
13281         }
13282     }
13283
13284   /* Sometimes we don't notice that a function is a static member, and
13285      build a METHOD_TYPE for it.  Fix that up now.  */
13286   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13287       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13288     {
13289       revert_static_member_fn (decl1);
13290       last_function_parms = TREE_CHAIN (last_function_parms);
13291       ctype = NULL_TREE;
13292     }
13293
13294   /* Warn if function was previously implicitly declared
13295      (but not if we warned then).  */
13296   if (! warn_implicit
13297       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13298     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13299
13300   /* Set up current_class_type, and enter the scope of the class, if
13301      appropriate.  */
13302   if (ctype)
13303     push_nested_class (ctype, 1);
13304   else if (DECL_STATIC_FUNCTION_P (decl1))
13305     push_nested_class (DECL_CONTEXT (decl1), 2);
13306
13307   /* Now that we have entered the scope of the class, we must restore
13308      the bindings for any template parameters surrounding DECL1, if it
13309      is an inline member template.  (Order is important; consider the
13310      case where a template parameter has the same name as a field of
13311      the class.)  It is not until after this point that
13312      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13313   if (flags & SF_INCLASS_INLINE)
13314     maybe_begin_member_template_processing (decl1);
13315
13316   /* Effective C++ rule 15.  See also c_expand_return.  */
13317   if (warn_ecpp
13318       && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
13319       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13320     cp_warning ("`operator=' should return a reference to `*this'");
13321
13322   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13323      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13324   if (!DECL_INITIAL (decl1))
13325     DECL_INITIAL (decl1) = error_mark_node;
13326
13327 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13328   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13329 #endif
13330
13331   /* This function exists in static storage.
13332      (This does not mean `static' in the C sense!)  */
13333   TREE_STATIC (decl1) = 1;
13334
13335   /* We must call push_template_decl after current_class_type is set
13336      up.  (If we are processing inline definitions after exiting a
13337      class scope, current_class_type will be NULL_TREE until set above
13338      by push_nested_class.)  */
13339   if (processing_template_decl)
13340     decl1 = push_template_decl (decl1);
13341
13342   /* We are now in the scope of the function being defined.  */
13343   current_function_decl = decl1;
13344
13345   /* Save the parm names or decls from this function's declarator
13346      where store_parm_decls will find them.  */
13347   current_function_parms = last_function_parms;
13348   current_function_parm_tags = last_function_parm_tags;
13349
13350   /* Make sure the parameter and return types are reasonable.  When
13351      you declare a function, these types can be incomplete, but they
13352      must be complete when you define the function.  */
13353   if (! processing_template_decl)
13354     check_function_type (decl1);
13355
13356   /* Build the return declaration for the function.  */
13357   restype = TREE_TYPE (fntype);
13358   if (!processing_template_decl)
13359     {
13360       if (!DECL_RESULT (decl1))
13361         {
13362           DECL_RESULT (decl1)
13363             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13364           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13365                                       DECL_RESULT (decl1));
13366         }
13367     }
13368   else
13369     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13370     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13371
13372   /* Initialize RTL machinery.  We cannot do this until
13373      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13374      even when processing a template; this is how we get
13375      CFUN set up, and our per-function variables initialized.  */
13376   bl = current_binding_level;
13377   init_function_start (decl1, input_filename, lineno);
13378   current_binding_level = bl;
13379   expanding_p = (flags & SF_EXPAND) != 0;
13380
13381   /* Even though we're inside a function body, we still don't want to
13382      call expand_expr to calculate the size of a variable-sized array.
13383      We haven't necessarily assigned RTL to all variables yet, so it's
13384      not safe to try to expand expressions involving them.  */
13385   immediate_size_expand = 0;
13386   cfun->x_dont_save_pending_sizes_p = 1;
13387
13388   /* If we're building a statement-tree, start the tree now.  */
13389   if (processing_template_decl || !expanding_p)
13390     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13391
13392   /* Let the user know we're compiling this function.  */
13393   if (processing_template_decl || !building_stmt_tree ())
13394     announce_function (decl1);
13395
13396   /* Record the decl so that the function name is defined.
13397      If we already have a decl for this name, and it is a FUNCTION_DECL,
13398      use the old decl.  */
13399   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13400     {
13401       /* A specialization is not used to guide overload resolution.  */
13402       if ((flag_guiding_decls
13403            || !DECL_TEMPLATE_SPECIALIZATION (decl1))
13404           && ! DECL_FUNCTION_MEMBER_P (decl1))
13405         decl1 = pushdecl (decl1);
13406       else
13407         {
13408           /* We need to set the DECL_CONTEXT. */
13409           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13410             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13411           /* And make sure we have enough default args.  */
13412           check_default_args (decl1);
13413         }
13414       fntype = TREE_TYPE (decl1);
13415     }
13416
13417   /* Reset these in case the call to pushdecl changed them.  */
13418   current_function_decl = decl1;
13419   cfun->decl = decl1;
13420
13421   /* Initialize the per-function data.  */
13422   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13423     {
13424       /* If we already parsed this function, and we're just expanding it
13425          now, restore saved state.  */
13426       struct binding_level *bl = current_binding_level;
13427       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13428       current_binding_level = bl;
13429
13430       /* This function is being processed in whole-function mode; we
13431          already did semantic analysis.  */
13432       cfun->x_whole_function_mode_p = 1;
13433
13434       /* If we decided that we didn't want to inline this function,
13435          make sure the back-end knows that.  */
13436       if (!current_function_cannot_inline)
13437         current_function_cannot_inline = cp_function_chain->cannot_inline;
13438
13439       /* We don't need the saved data anymore.  */
13440       free (DECL_SAVED_FUNCTION_DATA (decl1));
13441       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13442     }
13443   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13444     {
13445       /* We know that this was set up by `grokclassfn'.  We do not
13446          wait until `store_parm_decls', since evil parse errors may
13447          never get us to that point.  Here we keep the consistency
13448          between `current_class_type' and `current_class_ptr'.  */
13449       tree t = DECL_ARGUMENTS (decl1);
13450
13451       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13452                           162);
13453       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13454                           19990811);
13455
13456       cp_function_chain->x_current_class_ref
13457         = build_indirect_ref (t, NULL_PTR);
13458       cp_function_chain->x_current_class_ptr = t;
13459
13460       /* Constructors and destructors need to know whether they're "in
13461          charge" of initializing virtual base classes.  */
13462       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13463         current_in_charge_parm = TREE_CHAIN (t);
13464     }
13465
13466   if (DECL_INTERFACE_KNOWN (decl1))
13467     {
13468       tree ctx = decl_function_context (decl1);
13469
13470       if (DECL_NOT_REALLY_EXTERN (decl1))
13471         DECL_EXTERNAL (decl1) = 0;
13472
13473       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13474           && TREE_PUBLIC (ctx))
13475         /* This is a function in a local class in an extern inline
13476            function.  */
13477         comdat_linkage (decl1);
13478     }
13479   /* If this function belongs to an interface, it is public.
13480      If it belongs to someone else's interface, it is also external.
13481      This only affects inlines and template instantiations.  */
13482   else if (interface_unknown == 0
13483            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13484                || flag_alt_external_templates))
13485     {
13486       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13487           || processing_template_decl)
13488         {
13489           DECL_EXTERNAL (decl1)
13490             = (interface_only
13491                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13492                    && !DECL_VINDEX (decl1)));
13493
13494           /* For WIN32 we also want to put these in linkonce sections.  */
13495           maybe_make_one_only (decl1);
13496         }
13497       else
13498         DECL_EXTERNAL (decl1) = 0;
13499       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13500       DECL_INTERFACE_KNOWN (decl1) = 1;
13501     }
13502   else if (interface_unknown && interface_only
13503            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13504                || flag_alt_external_templates))
13505     {
13506       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13507          interface, we will have interface_only set but not
13508          interface_known.  In that case, we don't want to use the normal
13509          heuristics because someone will supply a #pragma implementation
13510          elsewhere, and deducing it here would produce a conflict.  */
13511       comdat_linkage (decl1);
13512       DECL_EXTERNAL (decl1) = 0;
13513       DECL_INTERFACE_KNOWN (decl1) = 1;
13514       DECL_DEFER_OUTPUT (decl1) = 1;
13515     }
13516   else
13517     {
13518       /* This is a definition, not a reference.
13519          So clear DECL_EXTERNAL.  */
13520       DECL_EXTERNAL (decl1) = 0;
13521
13522       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13523           && ! DECL_INTERFACE_KNOWN (decl1)
13524           /* Don't try to defer nested functions for now.  */
13525           && ! decl_function_context (decl1))
13526         DECL_DEFER_OUTPUT (decl1) = 1;
13527       else
13528         DECL_INTERFACE_KNOWN (decl1) = 1;
13529     }
13530
13531   if (doing_semantic_analysis_p ())
13532     {
13533       pushlevel (0);
13534       current_binding_level->parm_flag = 1;
13535     }
13536
13537   if (attrs)
13538     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13539
13540   if (!building_stmt_tree ())
13541     {
13542       GNU_xref_function (decl1, current_function_parms);
13543       make_function_rtl (decl1);
13544     }
13545
13546   /* Promote the value to int before returning it.  */
13547   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13548     restype = type_promotes_to (restype);
13549
13550   /* If this fcn was already referenced via a block-scope `extern' decl
13551      (or an implicit decl), propagate certain information about the usage.  */
13552   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13553     TREE_ADDRESSABLE (decl1) = 1;
13554
13555   if (DECL_RESULT (decl1) == NULL_TREE)
13556     {
13557       DECL_RESULT (decl1)
13558         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13559       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13560       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13561     }
13562
13563   ++function_depth;
13564
13565   if (DECL_DESTRUCTOR_P (decl1))
13566     {
13567       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13568       DECL_CONTEXT (dtor_label) = current_function_decl;
13569     }
13570   /* Under the old ABI we return `this' from constructors, so we make
13571      ordinary `return' statements in constructors jump to CTOR_LABEL;
13572      from there we return `this'.  Under the new ABI, we don't bother
13573      with any of this.  By not setting CTOR_LABEL the remainder of the
13574      machinery is automatically disabled.  */
13575   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13576     {
13577       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13578       DECL_CONTEXT (ctor_label) = current_function_decl;
13579     }
13580
13581   return 1;
13582 }
13583 \f
13584 /* Called after store_parm_decls for a function-try-block.  */
13585
13586 void
13587 expand_start_early_try_stmts ()
13588 {
13589   expand_start_try_stmts ();
13590 }
13591
13592 /* Store the parameter declarations into the current function declaration.
13593    This is called after parsing the parameter declarations, before
13594    digesting the body of the function.
13595
13596    Also install to binding contour return value identifier, if any.  */
13597
13598 void
13599 store_parm_decls ()
13600 {
13601   register tree fndecl = current_function_decl;
13602   register tree parm;
13603   int parms_have_cleanups = 0;
13604   tree cleanups = NULL_TREE;
13605
13606   /* This is a list of types declared among parms in a prototype.  */
13607   tree parmtags = current_function_parm_tags;
13608
13609   /* This is a chain of any other decls that came in among the parm
13610      declarations.  If a parm is declared with  enum {foo, bar} x;
13611      then CONST_DECLs for foo and bar are put here.  */
13612   tree nonparms = NULL_TREE;
13613
13614   /* Create a binding level for the parms.  */
13615   if (!building_stmt_tree ())
13616     expand_start_bindings (2);
13617
13618   if (current_function_parms)
13619     {
13620       /* This case is when the function was defined with an ANSI prototype.
13621          The parms already have decls, so we need not do anything here
13622          except record them as in effect
13623          and complain if any redundant old-style parm decls were written.  */
13624
13625       tree specparms = current_function_parms;
13626       tree next;
13627
13628       if (doing_semantic_analysis_p ())
13629         {
13630           /* Must clear this because it might contain TYPE_DECLs declared
13631              at class level.  */
13632           storedecls (NULL_TREE);
13633
13634           /* If we're doing semantic analysis, then we'll call pushdecl
13635              for each of these.  We must do them in reverse order so that
13636              they end in the correct forward order.  */
13637           specparms = nreverse (specparms);
13638         }
13639
13640       for (parm = specparms; parm; parm = next)
13641         {
13642           next = TREE_CHAIN (parm);
13643           if (TREE_CODE (parm) == PARM_DECL)
13644             {
13645               tree type = TREE_TYPE (parm);
13646
13647               if (doing_semantic_analysis_p ())
13648                 {
13649                   tree cleanup;
13650
13651                   if (DECL_NAME (parm) == NULL_TREE
13652                       || TREE_CODE (parm) != VOID_TYPE)
13653                     pushdecl (parm);
13654                   else
13655                     cp_error ("parameter `%D' declared void", parm);
13656
13657                   cleanup = (processing_template_decl
13658                              ? NULL_TREE
13659                              : maybe_build_cleanup (parm));
13660
13661                   if (cleanup)
13662                     cleanups = tree_cons (parm, cleanup, cleanups);
13663                 }
13664               else if (type != error_mark_node
13665                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13666                 parms_have_cleanups = 1;
13667             }
13668           else
13669             {
13670               /* If we find an enum constant or a type tag,
13671                  put it aside for the moment.  */
13672               TREE_CHAIN (parm) = NULL_TREE;
13673               nonparms = chainon (nonparms, parm);
13674             }
13675         }
13676
13677       if (doing_semantic_analysis_p ())
13678         {
13679           /* Get the decls in their original chain order
13680              and record in the function.  This is all and only the
13681              PARM_DECLs that were pushed into scope by the loop above.  */
13682           DECL_ARGUMENTS (fndecl) = getdecls ();
13683           storetags (chainon (parmtags, gettags ()));
13684         }
13685     }
13686   else
13687     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13688
13689   /* Now store the final chain of decls for the arguments
13690      as the decl-chain of the current lexical scope.
13691      Put the enumerators in as well, at the front so that
13692      DECL_ARGUMENTS is not modified.  */
13693   if (doing_semantic_analysis_p ())
13694     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13695
13696   /* Initialize the RTL code for the function.  */
13697   DECL_SAVED_INSNS (fndecl) = 0;
13698   if (! building_stmt_tree ())
13699     expand_function_start (fndecl, parms_have_cleanups);
13700
13701   current_function_parms_stored = 1;
13702
13703   /* If this function is `main', emit a call to `__main'
13704      to run global initializers, etc.  */
13705   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13706     expand_main_function ();
13707
13708   /* Now that we have initialized the parms, we can start their
13709      cleanups.  We cannot do this before, since expand_decl_cleanup
13710      should not be called before the parm can be used.  */
13711   while (cleanups)
13712     {
13713       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13714                            TREE_VALUE (cleanups));
13715       cleanups = TREE_CHAIN (cleanups);
13716     }
13717
13718   /* Create a binding contour which can be used to catch
13719      cleanup-generated temporaries.  Also, if the return value needs or
13720      has initialization, deal with that now.  */
13721   if (parms_have_cleanups)
13722     {
13723       pushlevel (0);
13724       if (!building_stmt_tree ())
13725         expand_start_bindings (2);
13726     }
13727
13728   /* Do the starting of the exception specifications, if we have any.  */
13729   if (flag_exceptions && !processing_template_decl
13730       && flag_enforce_eh_specs
13731       && building_stmt_tree ()
13732       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13733     current_eh_spec_try_block = expand_start_eh_spec ();
13734 }
13735
13736 /* Bind a name and initialization to the return value of
13737    the current function.  */
13738
13739 void
13740 store_return_init (decl)
13741      tree decl;
13742 {
13743   /* If this named return value comes in a register, put it in a
13744      pseudo-register.  */
13745   if (DECL_REGISTER (decl))
13746     {
13747       original_result_rtx = DECL_RTL (decl);
13748       /* Note that the mode of the old DECL_RTL may be wider than the
13749          mode of DECL_RESULT, depending on the calling conventions for
13750          the processor.  For example, on the Alpha, a 32-bit integer
13751          is returned in a DImode register -- the DECL_RESULT has
13752          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
13753          here, we use the mode the back-end has already assigned for
13754          the return value.  */
13755       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13756     }
13757 }
13758
13759 \f
13760 /* We have finished doing semantic analysis on DECL, but have not yet
13761    generated RTL for its body.  Save away our current state, so that
13762    when we want to generate RTL later we know what to do.  */
13763
13764 static void
13765 save_function_data (decl)
13766      tree decl;
13767 {
13768   struct language_function *f;
13769
13770   /* Save the language-specific per-function data so that we can
13771      get it back when we really expand this function.  */
13772   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13773                       19990908);
13774
13775   /* Make a copy.  */
13776   f = ((struct language_function *)
13777        xmalloc (sizeof (struct language_function)));
13778   bcopy ((char *) cp_function_chain, (char *) f,
13779          sizeof (struct language_function));
13780   DECL_SAVED_FUNCTION_DATA (decl) = f;
13781
13782   /* Clear out the bits we don't need.  */
13783   f->x_base_init_list = NULL_TREE;
13784   f->x_member_init_list = NULL_TREE;
13785   f->x_stmt_tree.x_last_stmt = NULL_TREE;
13786   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
13787   f->x_result_rtx = NULL_RTX;
13788   f->x_named_label_uses = NULL;
13789   f->bindings = NULL;
13790
13791   /* When we get back here again, we will be expanding.  */
13792   f->x_expanding_p = 1;
13793
13794   /* If we've already decided that we cannot inline this function, we
13795      must remember that fact when we actually go to expand the
13796      function.  */
13797   f->cannot_inline = current_function_cannot_inline;
13798 }
13799
13800 /* At the end of every constructor we generate to code to return
13801    `this'.  Do that now.  */
13802
13803 static void
13804 finish_constructor_body ()
13805 {
13806   /* Any return from a constructor will end up here.  */
13807   if (ctor_label)
13808     add_tree (build_min_nt (LABEL_STMT, ctor_label));
13809
13810   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13811      generate the return, rather than a goto to CTOR_LABEL.  */
13812   ctor_label = NULL_TREE;
13813   /* In check_return_expr we translate an empty return from a
13814      constructor to a return of `this'.  */
13815   finish_return_stmt (NULL_TREE);
13816   /* Mark the end of the constructor.  */
13817   add_tree (build_min_nt (CTOR_STMT));
13818 }
13819
13820 /* At the end of every destructor we generate code to restore virtual
13821    function tables to the values desired by base classes and to call
13822    to base class destructors.  Do that now.  */
13823
13824 static void
13825 finish_destructor_body ()
13826 {
13827   tree compound_stmt;
13828   tree virtual_size;
13829   tree exprstmt;
13830   tree if_stmt;
13831
13832   /* Create a block to contain all the extra code.  */
13833   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13834
13835   /* Any return from a destructor will end up here.  */
13836   add_tree (build_min_nt (LABEL_STMT, dtor_label));
13837
13838   /* Generate the code to call destructor on base class.  If this
13839      destructor belongs to a class with virtual functions, then set
13840      the virtual function table pointer to represent the type of our
13841      base class.  */
13842
13843   /* This side-effect makes call to `build_delete' generate the code
13844      we have to have at the end of this destructor.  `build_delete'
13845      will set the flag again.  */
13846   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13847
13848   exprstmt = build_delete (current_class_type,
13849                            current_class_ref,
13850                            sfk_base_destructor,
13851                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13852                            0);
13853
13854   if (exprstmt != error_mark_node
13855       && (TREE_CODE (exprstmt) != NOP_EXPR
13856           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13857           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13858     {
13859       if (exprstmt != void_zero_node)
13860         /* Don't call `expand_expr_stmt' if we're not going to do
13861            anything, since -Wall will give a diagnostic.  */
13862         finish_expr_stmt (exprstmt);
13863
13864       /* Run destructors for all virtual baseclasses.  */
13865       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13866         {
13867           tree vbases;
13868           tree if_stmt;
13869
13870           if_stmt = begin_if_stmt ();
13871           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13872                                       current_in_charge_parm,
13873                                       integer_two_node),
13874                                if_stmt);
13875
13876           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13877           /* The CLASSTYPE_VBASECLASSES list is in initialization
13878              order, so we have to march through it in reverse order.  */
13879           for (vbases = nreverse (copy_list (vbases));
13880                vbases;
13881                vbases = TREE_CHAIN (vbases))
13882             {
13883               tree vbase = TREE_VALUE (vbases);
13884
13885               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
13886                 {
13887                   tree vb = get_vbase
13888                     (BINFO_TYPE (vbase),
13889                      TYPE_BINFO (current_class_type));
13890                   finish_expr_stmt
13891                     (build_scoped_method_call
13892                      (current_class_ref, vb, base_dtor_identifier,
13893                       NULL_TREE));
13894                 }
13895             }
13896
13897           finish_then_clause (if_stmt);
13898           finish_if_stmt ();
13899         }
13900     }
13901
13902   virtual_size = c_sizeof (current_class_type);
13903
13904   /* At the end, call delete if that's what's requested.  */
13905
13906   /* FDIS sez: At the point of definition of a virtual destructor
13907      (including an implicit definition), non-placement operator delete
13908      shall be looked up in the scope of the destructor's class and if
13909      found shall be accessible and unambiguous.
13910
13911      This is somewhat unclear, but I take it to mean that if the class
13912      only defines placement deletes we don't do anything here.  So we
13913      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13914      they ever try to delete one of these.  */
13915   exprstmt = build_op_delete_call
13916     (DELETE_EXPR, current_class_ptr, virtual_size,
13917      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13918
13919   if_stmt = begin_if_stmt ();
13920   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13921                               current_in_charge_parm,
13922                               integer_one_node),
13923                        if_stmt);
13924   finish_expr_stmt (exprstmt);
13925   finish_then_clause (if_stmt);
13926   finish_if_stmt ();
13927
13928   /* Close the block we started above.  */
13929   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13930 }
13931
13932 /* Finish up a function declaration and compile that function
13933    all the way to assembler language output.  The free the storage
13934    for the function definition.
13935
13936    FLAGS is a bitwise or of the following values:
13937      1 - CALL_POPLEVEL
13938        An extra call to poplevel (and expand_end_bindings) must be
13939        made to take care of the binding contour for the base
13940        initializers.  This is only relevant for constructors.
13941      2 - INCLASS_INLINE
13942        We just finished processing the body of an in-class inline
13943        function definition.  (This processing will have taken place
13944        after the class definition is complete.)  */
13945
13946 tree
13947 finish_function (flags)
13948      int flags;
13949 {
13950   register tree fndecl = current_function_decl;
13951   tree fntype, ctype = NULL_TREE;
13952   /* Label to use if this function is supposed to return a value.  */
13953   tree no_return_label = NULL_TREE;
13954   int call_poplevel = (flags & 1) != 0;
13955   int inclass_inline = (flags & 2) != 0;
13956   int expand_p;
13957   int nested;
13958   int current_line = lineno;
13959
13960   /* When we get some parse errors, we can end up without a
13961      current_function_decl, so cope.  */
13962   if (fndecl == NULL_TREE)
13963     return error_mark_node;
13964
13965   nested = function_depth > 1;
13966   fntype = TREE_TYPE (fndecl);
13967
13968   /*  TREE_READONLY (fndecl) = 1;
13969       This caused &foo to be of type ptr-to-const-function
13970       which then got a warning when stored in a ptr-to-function variable.  */
13971
13972   /* This happens on strange parse errors.  */
13973   if (! current_function_parms_stored)
13974     {
13975       call_poplevel = 0;
13976       store_parm_decls ();
13977     }
13978
13979   /* For a cloned function, we've already got all the code we need;
13980      there's no need to add any extra bits.  */
13981   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
13982     ;
13983   else if (building_stmt_tree ())
13984     {
13985       if (DECL_CONSTRUCTOR_P (fndecl))
13986         {
13987           finish_constructor_body ();
13988           if (call_poplevel)
13989             do_poplevel ();
13990         }
13991       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13992         finish_destructor_body ();
13993       else if (DECL_MAIN_P (fndecl))
13994         {
13995           /* Make it so that `main' always returns 0 by default.  */
13996 #ifdef VMS
13997           finish_return_stmt (integer_one_node);
13998 #else
13999           finish_return_stmt (integer_zero_node);
14000 #endif
14001         }
14002
14003       /* Finish dealing with exception specifiers.  */
14004       if (flag_exceptions && !processing_template_decl
14005           && flag_enforce_eh_specs
14006           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14007         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14008                             (TREE_TYPE (current_function_decl)),
14009                             current_eh_spec_try_block);
14010     }
14011   else
14012     {
14013 #if 0
14014       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14015         {
14016           /* Keep this code around in case we later want to control debug info
14017              based on whether a type is "used".  (jason 1999-11-11) */
14018
14019           tree ttype = target_type (fntype);
14020           tree parmdecl;
14021
14022           if (IS_AGGR_TYPE (ttype))
14023             /* Let debugger know it should output info for this type.  */
14024             note_debug_info_needed (ttype);
14025
14026           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14027             {
14028               ttype = target_type (TREE_TYPE (parmdecl));
14029               if (IS_AGGR_TYPE (ttype))
14030                 /* Let debugger know it should output info for this type.  */
14031                 note_debug_info_needed (ttype);
14032             }
14033         }
14034 #endif
14035
14036       /* Clean house because we will need to reorder insns here.  */
14037       do_pending_stack_adjust ();
14038
14039       if (dtor_label)
14040         ;
14041       else if (DECL_CONSTRUCTOR_P (fndecl))
14042         {
14043           if (call_poplevel)
14044             do_poplevel ();
14045         }
14046       else if (return_label != NULL_RTX
14047                && flag_this_is_variable <= 0
14048                && current_function_return_value == NULL_TREE
14049                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14050         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14051
14052       if (flag_exceptions)
14053         expand_exception_blocks ();
14054
14055       /* If this function is supposed to return a value, ensure that
14056          we do not fall into the cleanups by mistake.  The end of our
14057          function will look like this:
14058
14059          user code (may have return stmt somewhere)
14060          goto no_return_label
14061          cleanup_label:
14062          cleanups
14063          goto return_label
14064          no_return_label:
14065          NOTE_INSN_FUNCTION_END
14066          return_label:
14067          things for return
14068
14069          If the user omits a return stmt in the USER CODE section, we
14070          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14071          Otherwise, we won't.  */
14072       if (no_return_label)
14073         {
14074           DECL_CONTEXT (no_return_label) = fndecl;
14075           DECL_INITIAL (no_return_label) = error_mark_node;
14076           DECL_SOURCE_FILE (no_return_label) = input_filename;
14077           DECL_SOURCE_LINE (no_return_label) = current_line;
14078           expand_goto (no_return_label);
14079         }
14080
14081       if (cleanup_label)
14082         {
14083           /* Remove the binding contour which is used
14084              to catch cleanup-generated temporaries.  */
14085           expand_end_bindings (0, 0, 0);
14086           poplevel (0, 0, 0);
14087
14088           /* Emit label at beginning of cleanup code for parameters.  */
14089           emit_label (cleanup_label);
14090         }
14091
14092       /* Get return value into register if that's where it's supposed
14093          to be.  */
14094       if (original_result_rtx)
14095         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14096
14097       /* Finish building code that will trigger warnings if users forget
14098          to make their functions return values.  */
14099       if (no_return_label || cleanup_label)
14100         emit_jump (return_label);
14101       if (no_return_label)
14102         {
14103           /* We don't need to call `expand_*_return' here because we
14104              don't need any cleanups here--this path of code is only
14105              for error checking purposes.  */
14106           expand_label (no_return_label);
14107         }
14108
14109       /* We hard-wired immediate_size_expand to zero in
14110          start_function.  Expand_function_end will decrement this
14111          variable.  So, we set the variable to one here, so that after
14112          the decrement it will remain zero.  */
14113       immediate_size_expand = 1;
14114
14115       /* Generate rtl for function exit.  */
14116       expand_function_end (input_filename, current_line, 1);
14117     }
14118
14119   /* We have to save this value here in case
14120      maybe_end_member_template_processing decides to pop all the
14121      template parameters.  */
14122   expand_p = !building_stmt_tree ();
14123
14124   /* If we're saving up tree structure, tie off the function now.  */
14125   if (!expand_p)
14126     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14127
14128   /* This must come after expand_function_end because cleanups might
14129      have declarations (from inline functions) that need to go into
14130      this function's blocks.  */
14131   if (doing_semantic_analysis_p ())
14132     {
14133       if (current_binding_level->parm_flag != 1)
14134         my_friendly_abort (122);
14135       poplevel (1, 0, 1);
14136     }
14137
14138   /* Remember that we were in class scope.  */
14139   if (current_class_name)
14140     ctype = current_class_type;
14141
14142   /* Must mark the RESULT_DECL as being in this function.  */
14143   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14144
14145   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14146      to the FUNCTION_DECL node itself.  */
14147   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14148
14149   /* Save away current state, if appropriate.  */
14150   if (!expanding_p && !processing_template_decl)
14151     save_function_data (fndecl);
14152
14153   /* If this function calls `setjmp' it cannot be inlined.  When
14154      `longjmp' is called it is not guaranteed to restore the value of
14155      local variables that have been modified since the call to
14156      `setjmp'.  So, if were to inline this function into some caller
14157      `c', then when we `longjmp', we might not restore all variables
14158      in `c'.  (It might seem, at first blush, that there's no way for
14159      this function to modify local variables in `c', but their
14160      addresses may have been stored somewhere accessible to this
14161      function.)  */
14162   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14163     DECL_UNINLINABLE (fndecl) = 1;
14164
14165   if (expand_p)
14166     {
14167       int returns_null;
14168       int returns_value;
14169
14170       /* So we can tell if jump_optimize sets it to 1.  */
14171       can_reach_end = 0;
14172
14173       /* Before we call rest_of_compilation (which will pop the
14174          CURRENT_FUNCTION), we must save these values.  */
14175       returns_null = current_function_returns_null;
14176       returns_value = current_function_returns_value;
14177
14178       /* If this is a nested function (like a template instantiation
14179          that we're compiling in the midst of compiling something
14180          else), push a new GC context.  That will keep local variables
14181          on the stack from being collected while we're doing the
14182          compilation of this function.  */
14183       if (function_depth > 1)
14184         ggc_push_context ();
14185
14186       /* Run the optimizers and output the assembler code for this
14187          function.  */
14188       rest_of_compilation (fndecl);
14189
14190       /* Undo the call to ggc_push_context above.  */
14191       if (function_depth > 1)
14192         ggc_pop_context ();
14193
14194       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14195         {
14196           /* Set DECL_EXTERNAL so that assemble_external will be called as
14197              necessary.  We'll clear it again in finish_file.  */
14198           if (! DECL_EXTERNAL (fndecl))
14199             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14200           DECL_EXTERNAL (fndecl) = 1;
14201           defer_fn (fndecl);
14202         }
14203
14204 #if 0
14205       /* Keep this code around in case we later want to control debug info
14206          based on whether a type is "used".  (jason 1999-11-11) */
14207
14208       if (ctype && TREE_ASM_WRITTEN (fndecl))
14209         note_debug_info_needed (ctype);
14210 #endif
14211
14212       returns_null |= can_reach_end;
14213
14214       /* Since we don't normally go through c_expand_return for constructors,
14215          this normally gets the wrong value.
14216          Also, named return values have their return codes emitted after
14217          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
14218       if (DECL_CONSTRUCTOR_P (fndecl)
14219           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
14220         returns_null = 0;
14221
14222       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14223         cp_warning ("`noreturn' function `%D' does return", fndecl);
14224       else if ((warn_return_type || pedantic)
14225                && returns_null
14226                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14227         {
14228           /* If this function returns non-void and control can drop through,
14229              complain.  */
14230           cp_warning ("control reaches end of non-void function `%D'", fndecl);
14231         }
14232       /* With just -W, complain only if function returns both with
14233          and without a value.  */
14234       else if (extra_warnings && returns_value && returns_null)
14235         warning ("this function may return with or without a value");
14236     }
14237   else
14238     {
14239       /* Clear out memory we no longer need.  */
14240       free_after_parsing (cfun);
14241       /* Since we never call rest_of_compilation, we never clear
14242          CFUN.  Do so explicitly.  */
14243       free_after_compilation (cfun);
14244       cfun = NULL;
14245     }
14246
14247   /* If this is a in-class inline definition, we may have to pop the
14248      bindings for the template parameters that we added in
14249      maybe_begin_member_template_processing when start_function was
14250      called.  */
14251   if (inclass_inline)
14252     maybe_end_member_template_processing ();
14253
14254   /* Leave the scope of the class.  */
14255   if (ctype)
14256     pop_nested_class ();
14257
14258   --function_depth;
14259
14260   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14261       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14262     {
14263       tree t;
14264
14265       /* Stop pointing to the local nodes about to be freed.  */
14266       /* But DECL_INITIAL must remain nonzero so we know this
14267          was an actual function definition.  */
14268       DECL_INITIAL (fndecl) = error_mark_node;
14269       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14270         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14271     }
14272
14273   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14274     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14275   if (DECL_STATIC_DESTRUCTOR (fndecl))
14276     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14277
14278   /* Clean up.  */
14279   if (! nested)
14280     {
14281       /* Let the error reporting routines know that we're outside a
14282          function.  For a nested function, this value is used in
14283          pop_cp_function_context and then reset via pop_function_context.  */
14284       current_function_decl = NULL_TREE;
14285       /* We don't really care about obstacks, but the middle-end
14286          sometimes cares on what obstck things are located.  */
14287       permanent_allocation (1);
14288     }
14289
14290   return fndecl;
14291 }
14292 \f
14293 /* Create the FUNCTION_DECL for a function definition.
14294    DECLSPECS and DECLARATOR are the parts of the declaration;
14295    they describe the return type and the name of the function,
14296    but twisted together in a fashion that parallels the syntax of C.
14297
14298    This function creates a binding context for the function body
14299    as well as setting up the FUNCTION_DECL in current_function_decl.
14300
14301    Returns a FUNCTION_DECL on success.
14302
14303    If the DECLARATOR is not suitable for a function (it defines a datum
14304    instead), we return 0, which tells yyparse to report a parse error.
14305
14306    May return void_type_node indicating that this method is actually
14307    a friend.  See grokfield for more details.
14308
14309    Came here with a `.pushlevel' .
14310
14311    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14312    CHANGES TO CODE IN `grokfield'.  */
14313
14314 tree
14315 start_method (declspecs, declarator, attrlist)
14316      tree declarator, declspecs, attrlist;
14317 {
14318   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14319                                 attrlist);
14320
14321   /* Something too ugly to handle.  */
14322   if (fndecl == NULL_TREE)
14323     return NULL_TREE;
14324
14325   /* Pass friends other than inline friend functions back.  */
14326   if (fndecl == void_type_node)
14327     return fndecl;
14328
14329   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14330     /* Not a function, tell parser to report parse error.  */
14331     return NULL_TREE;
14332
14333   if (DECL_IN_AGGR_P (fndecl))
14334     {
14335       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14336         {
14337           if (DECL_CONTEXT (fndecl)
14338               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14339             cp_error ("`%D' is already defined in class %s", fndecl,
14340                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14341         }
14342       return void_type_node;
14343     }
14344
14345   check_template_shadow (fndecl);
14346
14347   DECL_THIS_INLINE (fndecl) = 1;
14348
14349   if (flag_default_inline)
14350     DECL_INLINE (fndecl) = 1;
14351
14352   /* We process method specializations in finish_struct_1.  */
14353   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14354     fndecl = push_template_decl (fndecl);
14355
14356   if (! DECL_FRIEND_P (fndecl))
14357     {
14358       if (TREE_CHAIN (fndecl))
14359         {
14360           fndecl = copy_node (fndecl);
14361           TREE_CHAIN (fndecl) = NULL_TREE;
14362         }
14363
14364       if (DECL_CONSTRUCTOR_P (fndecl))
14365         {
14366           if (! grok_ctor_properties (current_class_type, fndecl))
14367             return void_type_node;
14368         }
14369       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14370         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14371     }
14372
14373   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14374
14375   /* Make a place for the parms */
14376   pushlevel (0);
14377   current_binding_level->parm_flag = 1;
14378
14379   DECL_IN_AGGR_P (fndecl) = 1;
14380   return fndecl;
14381 }
14382
14383 /* Go through the motions of finishing a function definition.
14384    We don't compile this method until after the whole class has
14385    been processed.
14386
14387    FINISH_METHOD must return something that looks as though it
14388    came from GROKFIELD (since we are defining a method, after all).
14389
14390    This is called after parsing the body of the function definition.
14391    STMTS is the chain of statements that makes up the function body.
14392
14393    DECL is the ..._DECL that `start_method' provided.  */
14394
14395 tree
14396 finish_method (decl)
14397      tree decl;
14398 {
14399   register tree fndecl = decl;
14400   tree old_initial;
14401
14402   register tree link;
14403
14404   if (decl == void_type_node)
14405     return decl;
14406
14407   old_initial = DECL_INITIAL (fndecl);
14408
14409   /* Undo the level for the parms (from start_method).
14410      This is like poplevel, but it causes nothing to be
14411      saved.  Saving information here confuses symbol-table
14412      output routines.  Besides, this information will
14413      be correctly output when this method is actually
14414      compiled.  */
14415
14416   /* Clear out the meanings of the local variables of this level;
14417      also record in each decl which block it belongs to.  */
14418
14419   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14420     {
14421       if (DECL_NAME (link) != NULL_TREE)
14422         pop_binding (DECL_NAME (link), link);
14423       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14424       DECL_CONTEXT (link) = NULL_TREE;
14425     }
14426
14427   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14428                       (HOST_WIDE_INT) current_binding_level->level_chain,
14429                       current_binding_level->parm_flag,
14430                       current_binding_level->keep);
14431
14432   poplevel (0, 0, 0);
14433
14434   DECL_INITIAL (fndecl) = old_initial;
14435
14436   /* We used to check if the context of FNDECL was different from
14437      current_class_type as another way to get inside here.  This didn't work
14438      for String.cc in libg++.  */
14439   if (DECL_FRIEND_P (fndecl))
14440     {
14441       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14442         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14443       decl = void_type_node;
14444     }
14445
14446   return decl;
14447 }
14448 \f
14449 /* Called when a new struct TYPE is defined.
14450    If this structure or union completes the type of any previous
14451    variable declaration, lay it out and output its rtl.  */
14452
14453 void
14454 hack_incomplete_structures (type)
14455      tree type;
14456 {
14457   tree *list;
14458   struct binding_level *level;
14459
14460   if (!type) /* Don't do this for class templates.  */
14461     return;
14462
14463   if (namespace_bindings_p ())
14464     {
14465       level = 0;
14466       list = &namespace_scope_incomplete;
14467     }
14468   else
14469     {
14470       level = innermost_nonclass_level ();
14471       list = &level->incomplete;
14472     }
14473
14474   while (1)
14475     {
14476       while (*list)
14477         {
14478           tree decl = TREE_VALUE (*list);
14479           if ((decl && TREE_TYPE (decl) == type)
14480               || (TREE_TYPE (decl)
14481                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14482                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14483             {
14484               int toplevel = toplevel_bindings_p ();
14485               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14486                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14487                 layout_type (TREE_TYPE (decl));
14488               layout_decl (decl, 0);
14489               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14490               if (! toplevel)
14491                 {
14492                   tree cleanup;
14493                   expand_decl (decl);
14494                   cleanup = maybe_build_cleanup (decl);
14495                   expand_decl_init (decl);
14496                   if (! expand_decl_cleanup (decl, cleanup))
14497                     cp_error ("parser lost in parsing declaration of `%D'",
14498                               decl);
14499                 }
14500               *list = TREE_CHAIN (*list);
14501             }
14502           else
14503             list = &TREE_CHAIN (*list);
14504         }
14505
14506       /* Keep looking through artificial binding levels generated
14507          for local variables.  */
14508       if (level && level->keep == 2)
14509         {
14510           level = level->level_chain;
14511           list = &level->incomplete;
14512         }
14513       else
14514         break;
14515     }
14516 }
14517
14518 /* If DECL is of a type which needs a cleanup, build that cleanup
14519    here.  */
14520
14521 tree
14522 maybe_build_cleanup (decl)
14523      tree decl;
14524 {
14525   tree type = TREE_TYPE (decl);
14526
14527   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14528     {
14529       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14530       tree rval;
14531
14532       if (TREE_CODE (type) == ARRAY_TYPE)
14533         rval = decl;
14534       else
14535         {
14536           mark_addressable (decl);
14537           rval = build_unary_op (ADDR_EXPR, decl, 0);
14538         }
14539
14540       /* Optimize for space over speed here.  */
14541       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14542           || flag_expensive_optimizations)
14543         flags |= LOOKUP_NONVIRTUAL;
14544
14545       rval = build_delete (TREE_TYPE (rval), rval,
14546                            sfk_complete_destructor, flags, 0);
14547
14548       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14549           && ! TYPE_HAS_DESTRUCTOR (type))
14550         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14551                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14552
14553       return rval;
14554     }
14555   return 0;
14556 }
14557 \f
14558 /* Expand a C++ expression at the statement level.
14559    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14560    The C++ type checker should get all of these out when
14561    expressions are combined with other, type-providing, expressions,
14562    leaving only orphan expressions, such as:
14563
14564    &class::bar;         / / takes its address, but does nothing with it.  */
14565
14566 void
14567 cplus_expand_expr_stmt (exp)
14568      tree exp;
14569 {
14570 #if 0
14571   /* We should do this eventually, but right now this causes regex.o from
14572      libg++ to miscompile, and tString to core dump.  */
14573   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14574 #endif
14575
14576   /* If we don't do this, we end up down inside expand_expr
14577      trying to do TYPE_MODE on the ERROR_MARK, and really
14578      go outside the bounds of the type.  */
14579   if (exp != error_mark_node)
14580     expand_expr_stmt (exp);
14581 }
14582
14583 /* When a stmt has been parsed, this function is called.  */
14584
14585 void
14586 finish_stmt ()
14587 {
14588   /* Always assume this statement was not an expression statement.  If
14589      it actually was an expression statement, its our callers
14590      responsibility to fix this up.  */
14591   last_expr_type = NULL_TREE;
14592 }
14593
14594 /* DECL was originally constructed as a non-static member function,
14595    but turned out to be static.  Update it accordingly.  */
14596
14597 void
14598 revert_static_member_fn (decl)
14599      tree decl;
14600 {
14601   tree tmp;
14602   tree function = TREE_TYPE (decl);
14603   tree args = TYPE_ARG_TYPES (function);
14604
14605   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14606       != TYPE_UNQUALIFIED)
14607     cp_error ("static member function `%#D' declared with type qualifiers",
14608               *decl);
14609
14610   args = TREE_CHAIN (args);
14611   tmp = build_function_type (TREE_TYPE (function), args);
14612   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14613   tmp = build_exception_variant (tmp,
14614                                  TYPE_RAISES_EXCEPTIONS (function));
14615   TREE_TYPE (decl) = tmp;
14616   if (DECL_ARGUMENTS (decl))
14617     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14618   DECL_STATIC_FUNCTION_P (decl) = 1;
14619 }
14620
14621 /* Initialize the variables used during compilation of a C++
14622    function.  */
14623
14624 static void
14625 push_cp_function_context (f)
14626      struct function *f;
14627 {
14628   struct language_function *p
14629     = ((struct language_function *)
14630        xcalloc (1, sizeof (struct language_function)));
14631   f->language = p;
14632
14633   /* It takes an explicit call to expand_body to generate RTL for a
14634      function.  */
14635   expanding_p = 0;
14636
14637   /* Whenever we start a new function, we destroy temporaries in the
14638      usual way.  */
14639   stmts_are_full_exprs_p = 1;
14640 }
14641
14642 /* Free the language-specific parts of F, now that we've finished
14643    compiling the function.  */
14644
14645 static void
14646 pop_cp_function_context (f)
14647      struct function *f;
14648 {
14649   if (f->language)
14650     free (f->language);
14651   f->language = 0;
14652 }
14653
14654 /* Mark P for GC.  */
14655
14656 static void
14657 mark_lang_function (p)
14658      struct language_function *p;
14659 {
14660   if (!p)
14661     return;
14662
14663   ggc_mark_tree (p->x_named_labels);
14664   ggc_mark_tree (p->x_ctor_label);
14665   ggc_mark_tree (p->x_dtor_label);
14666   ggc_mark_tree (p->x_base_init_list);
14667   ggc_mark_tree (p->x_member_init_list);
14668   ggc_mark_tree (p->x_current_class_ptr);
14669   ggc_mark_tree (p->x_current_class_ref);
14670   ggc_mark_tree (p->x_eh_spec_try_block);
14671   ggc_mark_tree (p->x_scope_stmt_stack);
14672
14673   ggc_mark_rtx (p->x_result_rtx);
14674
14675   mark_stmt_tree (&p->x_stmt_tree);
14676   mark_binding_level (&p->bindings);
14677 }
14678
14679 /* Mark the language-specific data in F for GC.  */
14680
14681 static void
14682 mark_cp_function_context (f)
14683      struct function *f;
14684 {
14685   mark_lang_function (f->language);
14686 }
14687
14688 void
14689 lang_mark_false_label_stack (l)
14690      struct label_node *l;
14691 {
14692   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14693   my_friendly_assert (l == NULL, 19990904);
14694 }
14695
14696 void
14697 lang_mark_tree (t)
14698      tree t;
14699 {
14700   enum tree_code code = TREE_CODE (t);
14701   if (code == IDENTIFIER_NODE)
14702     {
14703       struct lang_identifier *li = (struct lang_identifier *) t;
14704       struct lang_id2 *li2 = li->x;
14705       ggc_mark_tree (li->namespace_bindings);
14706       ggc_mark_tree (li->bindings);
14707       ggc_mark_tree (li->class_value);
14708       ggc_mark_tree (li->class_template_info);
14709
14710       if (li2)
14711         {
14712           ggc_mark_tree (li2->label_value);
14713           ggc_mark_tree (li2->implicit_decl);
14714           ggc_mark_tree (li2->error_locus);
14715         }
14716     }
14717   else if (code == CPLUS_BINDING)
14718     {
14719       if (BINDING_HAS_LEVEL_P (t))
14720         mark_binding_level (&BINDING_LEVEL (t));
14721       else
14722         ggc_mark_tree (BINDING_SCOPE (t));
14723       ggc_mark_tree (BINDING_VALUE (t));
14724     }
14725   else if (code == OVERLOAD)
14726     ggc_mark_tree (OVL_FUNCTION (t));
14727   else if (code == TEMPLATE_PARM_INDEX)
14728     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14729   else if (TREE_CODE_CLASS (code) == 'd')
14730     {
14731       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14732
14733       if (ld)
14734         {
14735           ggc_mark (ld);
14736           if (!DECL_GLOBAL_CTOR_P (t)
14737               && !DECL_GLOBAL_DTOR_P (t)
14738               && !DECL_THUNK_P (t))
14739             ggc_mark_tree (ld->decl_flags.u2.access);
14740           ggc_mark_tree (ld->decl_flags.context);
14741           if (TREE_CODE (t) != NAMESPACE_DECL)
14742             ggc_mark_tree (ld->decl_flags.u.template_info);
14743           else
14744             mark_binding_level (&NAMESPACE_LEVEL (t));
14745           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14746             {
14747               ggc_mark_tree (ld->befriending_classes);
14748               ggc_mark_tree (ld->saved_tree);
14749               ggc_mark_tree (ld->cloned_function);
14750               ggc_mark_tree (ld->vtt_parm);
14751               if (TREE_CODE (t) == TYPE_DECL)
14752                 ggc_mark_tree (ld->u.sorted_fields);
14753               else if (TREE_CODE (t) == FUNCTION_DECL
14754                        && !DECL_PENDING_INLINE_P (t))
14755                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14756             }
14757         }
14758     }
14759   else if (TREE_CODE_CLASS (code) == 't')
14760     {
14761       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14762
14763       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14764                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14765         {
14766           ggc_mark (lt);
14767           ggc_mark_tree (lt->vfields);
14768           ggc_mark_tree (lt->vbases);
14769           ggc_mark_tree (lt->tags);
14770           ggc_mark_tree (lt->size);
14771           ggc_mark_tree (lt->pure_virtuals);
14772           ggc_mark_tree (lt->friend_classes);
14773           ggc_mark_tree (lt->rtti);
14774           ggc_mark_tree (lt->methods);
14775           ggc_mark_tree (lt->template_info);
14776           ggc_mark_tree (lt->befriending_classes);
14777         }
14778       else if (lt)
14779         /* In the case of pointer-to-member function types, the
14780            TYPE_LANG_SPECIFIC is really just a tree.  */
14781         ggc_mark_tree ((tree) lt);
14782     }
14783 }