gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001  Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "flags.h"
  37 #include "cp-tree.h"
  38 #include "decl.h"
  39 #include "lex.h"
  40 #include "output.h"
  41 #include "except.h"
  42 #include "toplev.h"
  43 #include "../hash.h"
  44 #include "ggc.h"
  45 #include "tm_p.h"
  46
  47 extern int current_class_depth;
  48
  49 extern tree global_namespace;
  50
  51 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  52
  53 #ifndef BOOL_TYPE_SIZE
  54 #ifdef SLOW_BYTE_ACCESS
  55 /* In the new ABI, `bool' has size and alignment `1', on all
  56    platforms.  */
  57 #define BOOL_TYPE_SIZE \
  58   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  59 #else
  60 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  61 #endif
  62 #endif
  63
  64 static tree grokparms                           PARAMS ((tree));
  65 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  66
  67 static void push_binding_level PARAMS ((struct binding_level *, int,
  68                                       int));
  69 static void pop_binding_level PARAMS ((void));
  70 static void suspend_binding_level PARAMS ((void));
  71 static void resume_binding_level PARAMS ((struct binding_level *));
  72 static struct binding_level *make_binding_level PARAMS ((void));
  73 static void declare_namespace_level PARAMS ((void));
  74 static int decl_jump_unsafe PARAMS ((tree));
  75 static void storedecls PARAMS ((tree));
  76 static void require_complete_types_for_parms PARAMS ((tree));
  77 static int ambi_op_p PARAMS ((enum tree_code));
  78 static int unary_op_p PARAMS ((enum tree_code));
  79 static tree store_bindings PARAMS ((tree, tree));
  80 static tree lookup_tag_reverse PARAMS ((tree, tree));
  81 static tree obscure_complex_init PARAMS ((tree, tree));
  82 static tree lookup_name_real PARAMS ((tree, int, int, int));
  83 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  84 static void grok_reference_init PARAMS ((tree, tree, tree));
  85 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  86                               enum overload_flags, tree,
  87                               tree, int, int, int, int, int, int, tree));
  88 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  89 static tree lookup_tag PARAMS ((enum tree_code, tree,
  90                               struct binding_level *, int));
  91 static void set_identifier_type_value_with_scope
  92         PARAMS ((tree, tree, struct binding_level *));
  93 static void record_unknown_type PARAMS ((tree, const char *));
  94 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  95 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  96 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
  97                                   int));
  98 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
  99 static void check_for_uninitialized_const_var PARAMS ((tree));
 100 static unsigned long typename_hash PARAMS ((hash_table_key));
 101 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 102 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 103 static int add_binding PARAMS ((tree, tree));
 104 static void pop_binding PARAMS ((tree, tree));
 105 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 106 static tree find_binding PARAMS ((tree, tree));
 107 static tree select_decl PARAMS ((tree, int));
 108 static int lookup_flags PARAMS ((int, int));
 109 static tree qualify_lookup PARAMS ((tree, int));
 110 static tree record_builtin_java_type PARAMS ((const char *, int));
 111 static const char *tag_name PARAMS ((enum tag_types code));
 112 static void find_class_binding_level PARAMS ((void));
 113 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 114 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 115 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 116 static int walk_globals_r PARAMS ((tree, void *));
 117 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 118 static tree make_label_decl PARAMS ((tree, int));
 119 static void use_label PARAMS ((tree));
 120 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 121                                            const char *, int));
 122 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 123 static void check_switch_goto PARAMS ((struct binding_level *));
 124 static void check_previous_gotos PARAMS ((tree));
 125 static void pop_label PARAMS ((tree, tree));
 126 static void pop_labels PARAMS ((tree));
 127 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 128 static void layout_var_decl PARAMS ((tree));
 129 static void maybe_commonize_var PARAMS ((tree));
 130 static tree check_initializer PARAMS ((tree, tree));
 131 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 132 static void push_cp_function_context PARAMS ((struct function *));
 133 static void pop_cp_function_context PARAMS ((struct function *));
 134 static void mark_binding_level PARAMS ((void *));
 135 static void mark_named_label_lists PARAMS ((void *, void *));
 136 static void mark_cp_function_context PARAMS ((struct function *));
 137 static void mark_saved_scope PARAMS ((void *));
 138 static void mark_lang_function PARAMS ((struct cp_language_function *));
 139 static void save_function_data PARAMS ((tree));
 140 static void check_function_type PARAMS ((tree, tree));
 141 static void destroy_local_var PARAMS ((tree));
 142 static void finish_constructor_body PARAMS ((void));
 143 static void finish_destructor_body PARAMS ((void));
 144 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 145 static tree get_atexit_node PARAMS ((void));
 146 static tree get_dso_handle_node PARAMS ((void));
 147 static tree start_cleanup_fn PARAMS ((void));
 148 static void end_cleanup_fn PARAMS ((void));
 149 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 150 static void initialize_predefined_identifiers PARAMS ((void));
 151 static tree check_special_function_return_type
 152   PARAMS ((special_function_kind, tree, tree, tree));
 153 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 154 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 155 static void store_parm_decls PARAMS ((tree));
 156 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 157
 158 #if defined (DEBUG_CP_BINDING_LEVELS)
 159 static void indent PARAMS ((void));
 160 #endif
 161
 162 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 163 tree error_mark_list;
 164
 165 /* The following symbols are subsumed in the cp_global_trees array, and
 166    listed here individually for documentation purposes.
 167
 168    C++ extensions
 169         tree wchar_decl_node;
 170
 171         tree vtable_entry_type;
 172         tree delta_type_node;
 173 #if 0
 174    Old rtti stuff.
 175         tree __baselist_desc_type_node;
 176         tree __i_desc_type_node, __m_desc_type_node;
 177         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 178 #endif
 179         tree __t_desc_type_node;
 180 #if 0
 181         tree __tp_desc_type_node;
 182 #endif
 183         tree ti_desc_type_node;
 184         tree bltn_desc_type_node, ptr_desc_type_node;
 185         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 186         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 187         tree ptm_desc_type_node;
 188         tree base_desc_type_node;
 189 #if 0
 190    Not needed yet?  May be needed one day?
 191         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 192         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 193         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 194 #endif
 195
 196         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 197         tree unknown_type_node;
 198
 199    Array type `vtable_entry_type[]'
 200
 201         tree vtbl_type_node;
 202         tree vtbl_ptr_type_node;
 203
 204    Namespaces,
 205
 206         tree std_node;
 207         tree abi_node;
 208
 209    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 210    one that the user will declare, but sufficient to be called
 211    by routines that want to abort the program.
 212
 213         tree abort_fndecl;
 214
 215    The FUNCTION_DECL for the default `::operator delete'.
 216
 217         tree global_delete_fndecl;
 218
 219    Used by RTTI
 220         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 221         tree tinfo_var_id;
 222
 223 */
 224
 225 tree cp_global_trees[CPTI_MAX];
 226
 227 /* Indicates that there is a type value in some namespace, although
 228    that is not necessarily in scope at the moment.  */
 229
 230 static tree global_type_node;
 231
 232 /* If non-zero, this is the number of times we have entered the `std'
 233    namespace when we are treating that namespace as an alias for the
 234    global namespace.  */
 235 static int in_fake_std;
 236
 237 /* Expect only namespace names now. */
 238 static int only_namespace_names;
 239
 240 /* Used only for jumps to as-yet undefined labels, since jumps to
 241    defined labels can have their validity checked immediately.  */
 242
 243 struct named_label_use_list
 244 {
 245   struct binding_level *binding_level;
 246   tree names_in_scope;
 247   tree label_decl;
 248   const char *filename_o_goto;
 249   int lineno_o_goto;
 250   struct named_label_use_list *next;
 251 };
 252
 253 #define named_label_uses cp_function_chain->x_named_label_uses
 254
 255 /* A list of objects which have constructors or destructors
 256    which reside in the global scope.  The decl is stored in
 257    the TREE_VALUE slot and the initializer is stored
 258    in the TREE_PURPOSE slot.  */
 259 tree static_aggregates;
 260
 261 /* -- end of C++ */
 262
 263 /* A node for the integer constants 2, and 3.  */
 264
 265 tree integer_two_node, integer_three_node;
 266
 267 /* Parsing a function declarator leaves here a chain of structure
 268    and enum types declared in the parmlist.  */
 269
 270 static tree last_function_parm_tags;
 271
 272 /* Similar, for last_function_parm_tags.  */
 273 tree last_function_parms;
 274 static tree current_function_parm_tags;
 275
 276 /* A list of all LABEL_DECLs in the function that have names.  Here so
 277    we can clear out their names' definitions at the end of the
 278    function, and so we can check the validity of jumps to these labels.  */
 279
 280 struct named_label_list
 281 {
 282   struct binding_level *binding_level;
 283   tree names_in_scope;
 284   tree old_value;
 285   tree label_decl;
 286   tree bad_decls;
 287   int eh_region;
 288   struct named_label_list *next;
 289 };
 290
 291 #define named_labels cp_function_chain->x_named_labels
 292
 293 /* Set to 0 at beginning of a function definition, and whenever
 294    a label (case or named) is defined.  Set to value of expression
 295    returned from function when that value can be transformed into
 296    a named return value.  */
 297
 298 tree current_function_return_value;
 299
 300 /* Nonzero means use the ISO C94 dialect of C.  */
 301
 302 int flag_isoc94;
 303
 304 /* Nonzero means use the ISO C99 dialect of C.  */
 305
 306 int flag_isoc99;
 307
 308 /* Nonzero means we are a hosted implementation for code shared with C.  */
 309
 310 int flag_hosted = 1;
 311
 312 /* Nonzero means add default format_arg attributes for functions not
 313    in ISO C.  */
 314
 315 int flag_noniso_default_format_attributes = 1;
 316
 317 /* Nonzero if we want to conserve space in the .o files.  We do this
 318    by putting uninitialized data and runtime initialized data into
 319    .common instead of .data at the expense of not flagging multiple
 320    definitions.  */
 321 extern int flag_conserve_space;
 322 \f
 323 /* C and C++ flags are in decl2.c.  */
 324
 325 /* Flag used when debugging spew.c */
 326
 327 extern int spew_debug;
 328
 329 /* A expression of value 0 with the same precision as a sizetype
 330    node, but signed.  */
 331 tree signed_size_zero_node;
 332
 333 /* The name of the anonymous namespace, throughout this translation
 334    unit.  */
 335 tree anonymous_namespace_name;
 336
 337 /* The number of function bodies which we are currently processing.
 338    (Zero if we are at namespace scope, one inside the body of a
 339    function, two inside the body of a function in a local class, etc.)  */
 340 int function_depth;
 341 \f
 342 /* For each binding contour we allocate a binding_level structure
 343    which records the names defined in that contour.
 344    Contours include:
 345     0) the global one
 346     1) one for each function definition,
 347        where internal declarations of the parameters appear.
 348     2) one for each compound statement,
 349        to record its declarations.
 350
 351    The current meaning of a name can be found by searching the levels
 352    from the current one out to the global one.
 353
 354    Off to the side, may be the class_binding_level.  This exists only
 355    to catch class-local declarations.  It is otherwise nonexistent.
 356
 357    Also there may be binding levels that catch cleanups that must be
 358    run when exceptions occur.  Thus, to see whether a name is bound in
 359    the current scope, it is not enough to look in the
 360    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 361    instead.  */
 362
 363 /* Note that the information in the `names' component of the global contour
 364    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 365
 366 struct binding_level
 367   {
 368     /* A chain of _DECL nodes for all variables, constants, functions,
 369        and typedef types.  These are in the reverse of the order
 370        supplied.  There may be OVERLOADs on this list, too, but they
 371        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 372     tree names;
 373
 374     /* A list of structure, union and enum definitions, for looking up
 375        tag names.
 376        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 377        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 378        or ENUMERAL_TYPE node.
 379
 380        C++: the TREE_VALUE nodes can be simple types for
 381        component_bindings.  */
 382     tree tags;
 383
 384     /* A list of USING_DECL nodes. */
 385     tree usings;
 386
 387     /* A list of used namespaces. PURPOSE is the namespace,
 388        VALUE the common ancestor with this binding_level's namespace. */
 389     tree using_directives;
 390
 391     /* If this binding level is the binding level for a class, then
 392        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 393        is the name of an entity bound in the class.  The TREE_TYPE is
 394        the DECL bound by this name in the class.  */
 395     tree class_shadowed;
 396
 397     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 398        is used for all binding levels. In addition the TREE_VALUE is the
 399        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 400     tree type_shadowed;
 401
 402     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 403        label in this scope.  The TREE_PURPOSE is the previous value of
 404        the IDENTIFIER_LABEL VALUE.  */
 405     tree shadowed_labels;
 406
 407     /* For each level (except not the global one),
 408        a chain of BLOCK nodes for all the levels
 409        that were entered and exited one level down.  */
 410     tree blocks;
 411
 412     /* The _TYPE node for this level, if parm_flag == 2.  */
 413     tree this_class;
 414
 415     /* The binding level which this one is contained in (inherits from).  */
 416     struct binding_level *level_chain;
 417
 418     /* List of decls in `names' that have incomplete
 419        structure or union types.  */
 420     tree incomplete;
 421
 422     /* List of VAR_DECLS saved from a previous for statement.
 423        These would be dead in ISO-conforming code, but might
 424        be referenced in ARM-era code.  These are stored in a
 425        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 426     tree dead_vars_from_for;
 427
 428     /* 1 for the level that holds the parameters of a function.
 429        2 for the level that holds a class declaration.  */
 430     unsigned parm_flag : 2;
 431
 432     /* 1 means make a BLOCK for this level regardless of all else.
 433        2 for temporary binding contours created by the compiler.  */
 434     unsigned keep : 2;
 435
 436     /* Nonzero if this level "doesn't exist" for tags.  */
 437     unsigned tag_transparent : 1;
 438
 439     /* Nonzero if this level can safely have additional
 440        cleanup-needing variables added to it.  */
 441     unsigned more_cleanups_ok : 1;
 442     unsigned have_cleanups : 1;
 443
 444     /* Nonzero if this scope is for storing the decls for template
 445        parameters and generic decls; these decls will be discarded and
 446        replaced with a TEMPLATE_DECL.  */
 447     unsigned template_parms_p : 1;
 448
 449     /* Nonzero if this scope corresponds to the `<>' in a
 450        `template <>' clause.  Whenever this flag is set,
 451        TEMPLATE_PARMS_P will be set as well.  */
 452     unsigned template_spec_p : 1;
 453
 454     /* This is set for a namespace binding level.  */
 455     unsigned namespace_p : 1;
 456
 457     /* True if this level is that of a for-statement where we need to
 458        worry about ambiguous (ARM or ISO) scope rules.  */
 459     unsigned is_for_scope : 1;
 460
 461     /* True if this level corresponds to an EH region, as for a try block.
 462        Currently this information is only available while building the
 463        tree structure.  */
 464     unsigned eh_region : 1;
 465
 466     /* Four bits left for this word.  */
 467
 468 #if defined(DEBUG_CP_BINDING_LEVELS)
 469     /* Binding depth at which this level began.  */
 470     unsigned binding_depth;
 471 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 472   };
 473
 474 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 475
 476 /* The binding level currently in effect.  */
 477
 478 #define current_binding_level                   \
 479   (cfun                                         \
 480    ? cp_function_chain->bindings                \
 481    : scope_chain->bindings)
 482
 483 /* The binding level of the current class, if any.  */
 484
 485 #define class_binding_level scope_chain->class_bindings
 486
 487 /* A chain of binding_level structures awaiting reuse.  */
 488
 489 static struct binding_level *free_binding_level;
 490
 491 /* The outermost binding level, for names of file scope.
 492    This is created when the compiler is started and exists
 493    through the entire run.  */
 494
 495 static struct binding_level *global_binding_level;
 496
 497 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 498
 499 static int keep_next_level_flag;
 500
 501 #if defined(DEBUG_CP_BINDING_LEVELS)
 502 static int binding_depth = 0;
 503 static int is_class_level = 0;
 504
 505 static void
 506 indent ()
 507 {
 508   register unsigned i;
 509
 510   for (i = 0; i < binding_depth*2; i++)
 511     putc (' ', stderr);
 512 }
 513 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 514
 515 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 516
 517 static void
 518 push_binding_level (newlevel, tag_transparent, keep)
 519      struct binding_level *newlevel;
 520      int tag_transparent, keep;
 521 {
 522   /* Add this level to the front of the chain (stack) of levels that
 523      are active.  */
 524   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 525   newlevel->level_chain = current_binding_level;
 526   current_binding_level = newlevel;
 527   newlevel->tag_transparent = tag_transparent;
 528   newlevel->more_cleanups_ok = 1;
 529
 530   newlevel->keep = keep;
 531 #if defined(DEBUG_CP_BINDING_LEVELS)
 532   newlevel->binding_depth = binding_depth;
 533   indent ();
 534   fprintf (stderr, "push %s level 0x%08x line %d\n",
 535            (is_class_level) ? "class" : "block", newlevel, lineno);
 536   is_class_level = 0;
 537   binding_depth++;
 538 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 539 }
 540
 541 /* Find the innermost enclosing class scope, and reset
 542    CLASS_BINDING_LEVEL appropriately.  */
 543
 544 static void
 545 find_class_binding_level ()
 546 {
 547   struct binding_level *level = current_binding_level;
 548
 549   while (level && level->parm_flag != 2)
 550     level = level->level_chain;
 551   if (level && level->parm_flag == 2)
 552     class_binding_level = level;
 553   else
 554     class_binding_level = 0;
 555 }
 556
 557 static void
 558 pop_binding_level ()
 559 {
 560   if (global_binding_level)
 561     {
 562       /* Cannot pop a level, if there are none left to pop.  */
 563       if (current_binding_level == global_binding_level)
 564         my_friendly_abort (123);
 565     }
 566   /* Pop the current level, and free the structure for reuse.  */
 567 #if defined(DEBUG_CP_BINDING_LEVELS)
 568   binding_depth--;
 569   indent ();
 570   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 571           (is_class_level) ? "class" : "block",
 572           current_binding_level, lineno);
 573   if (is_class_level != (current_binding_level == class_binding_level))
 574     {
 575       indent ();
 576       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 577     }
 578   is_class_level = 0;
 579 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 580   {
 581     register struct binding_level *level = current_binding_level;
 582     current_binding_level = current_binding_level->level_chain;
 583     level->level_chain = free_binding_level;
 584 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 585     if (level->binding_depth != binding_depth)
 586       abort ();
 587 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 588     free_binding_level = level;
 589     find_class_binding_level ();
 590   }
 591 }
 592
 593 static void
 594 suspend_binding_level ()
 595 {
 596   if (class_binding_level)
 597     current_binding_level = class_binding_level;
 598
 599   if (global_binding_level)
 600     {
 601       /* Cannot suspend a level, if there are none left to suspend.  */
 602       if (current_binding_level == global_binding_level)
 603         my_friendly_abort (123);
 604     }
 605   /* Suspend the current level.  */
 606 #if defined(DEBUG_CP_BINDING_LEVELS)
 607   binding_depth--;
 608   indent ();
 609   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 610           (is_class_level) ? "class" : "block",
 611           current_binding_level, lineno);
 612   if (is_class_level != (current_binding_level == class_binding_level))
 613     {
 614       indent ();
 615       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 616     }
 617   is_class_level = 0;
 618 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 619   current_binding_level = current_binding_level->level_chain;
 620   find_class_binding_level ();
 621 }
 622
 623 static void
 624 resume_binding_level (b)
 625      struct binding_level *b;
 626 {
 627   /* Resuming binding levels is meant only for namespaces,
 628      and those cannot nest into classes. */
 629   my_friendly_assert(!class_binding_level, 386);
 630   /* Also, resuming a non-directly nested namespace is a no-no.  */
 631   my_friendly_assert(b->level_chain == current_binding_level, 386);
 632   current_binding_level = b;
 633 #if defined(DEBUG_CP_BINDING_LEVELS)
 634   b->binding_depth = binding_depth;
 635   indent ();
 636   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 637            (is_class_level) ? "class" : "block", b, lineno);
 638   is_class_level = 0;
 639   binding_depth++;
 640 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 641 }
 642 \f
 643 /* Create a new `struct binding_level'.  */
 644
 645 static
 646 struct binding_level *
 647 make_binding_level ()
 648 {
 649   /* NOSTRICT */
 650   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 651 }
 652
 653 /* Nonzero if we are currently in the global binding level.  */
 654
 655 int
 656 global_bindings_p ()
 657 {
 658   return current_binding_level == global_binding_level;
 659 }
 660
 661 /* Return the innermost binding level that is not for a class scope.  */
 662
 663 static struct binding_level *
 664 innermost_nonclass_level ()
 665 {
 666   struct binding_level *b;
 667
 668   b = current_binding_level;
 669   while (b->parm_flag == 2)
 670     b = b->level_chain;
 671
 672   return b;
 673 }
 674
 675 /* Nonzero if we are currently in a toplevel binding level.  This
 676    means either the global binding level or a namespace in a toplevel
 677    binding level.  Since there are no non-toplevel namespace levels,
 678    this really means any namespace or template parameter level.  We
 679    also include a class whose context is toplevel.  */
 680
 681 int
 682 toplevel_bindings_p ()
 683 {
 684   struct binding_level *b = innermost_nonclass_level ();
 685
 686   return b->namespace_p || b->template_parms_p;
 687 }
 688
 689 /* Nonzero if this is a namespace scope, or if we are defining a class
 690    which is itself at namespace scope, or whose enclosing class is
 691    such a class, etc.  */
 692
 693 int
 694 namespace_bindings_p ()
 695 {
 696   struct binding_level *b = innermost_nonclass_level ();
 697
 698   return b->namespace_p;
 699 }
 700
 701 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 702    unconditionally.  Otherwise, use the normal logic to decide whether
 703    or not to create a BLOCK.  */
 704
 705 void
 706 keep_next_level (keep)
 707      int keep;
 708 {
 709   keep_next_level_flag = keep;
 710 }
 711
 712 /* Nonzero if the current level needs to have a BLOCK made.  */
 713
 714 int
 715 kept_level_p ()
 716 {
 717   return (current_binding_level->blocks != NULL_TREE
 718           || current_binding_level->keep
 719           || current_binding_level->names != NULL_TREE
 720           || (current_binding_level->tags != NULL_TREE
 721               && !current_binding_level->tag_transparent));
 722 }
 723
 724 static void
 725 declare_namespace_level ()
 726 {
 727   current_binding_level->namespace_p = 1;
 728 }
 729
 730 /* Returns non-zero if this scope was created to store template
 731    parameters.  */
 732
 733 int
 734 template_parm_scope_p ()
 735 {
 736   return current_binding_level->template_parms_p;
 737 }
 738
 739 /* Returns the kind of template specialization we are currently
 740    processing, given that it's declaration contained N_CLASS_SCOPES
 741    explicit scope qualifications.  */
 742
 743 tmpl_spec_kind
 744 current_tmpl_spec_kind (n_class_scopes)
 745      int n_class_scopes;
 746 {
 747   int n_template_parm_scopes = 0;
 748   int seen_specialization_p = 0;
 749   int innermost_specialization_p = 0;
 750   struct binding_level *b;
 751
 752   /* Scan through the template parameter scopes.  */
 753   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 754     {
 755       /* If we see a specialization scope inside a parameter scope,
 756          then something is wrong.  That corresponds to a declaration
 757          like:
 758
 759             template <class T> template <> ...
 760
 761          which is always illegal since [temp.expl.spec] forbids the
 762          specialization of a class member template if the enclosing
 763          class templates are not explicitly specialized as well.  */
 764       if (b->template_spec_p)
 765         {
 766           if (n_template_parm_scopes == 0)
 767             innermost_specialization_p = 1;
 768           else
 769             seen_specialization_p = 1;
 770         }
 771       else if (seen_specialization_p == 1)
 772         return tsk_invalid_member_spec;
 773
 774       ++n_template_parm_scopes;
 775     }
 776
 777   /* Handle explicit instantiations.  */
 778   if (processing_explicit_instantiation)
 779     {
 780       if (n_template_parm_scopes != 0)
 781         /* We've seen a template parameter list during an explicit
 782            instantiation.  For example:
 783
 784              template <class T> template void f(int);
 785
 786            This is erroneous.  */
 787         return tsk_invalid_expl_inst;
 788       else
 789         return tsk_expl_inst;
 790     }
 791
 792   if (n_template_parm_scopes < n_class_scopes)
 793     /* We've not seen enough template headers to match all the
 794        specialized classes present.  For example:
 795
 796          template <class T> void R<T>::S<T>::f(int);
 797
 798        This is illegal; there needs to be one set of template
 799        parameters for each class.  */
 800     return tsk_insufficient_parms;
 801   else if (n_template_parm_scopes == n_class_scopes)
 802     /* We're processing a non-template declaration (even though it may
 803        be a member of a template class.)  For example:
 804
 805          template <class T> void S<T>::f(int);
 806
 807        The `class T' maches the `S<T>', leaving no template headers
 808        corresponding to the `f'.  */
 809     return tsk_none;
 810   else if (n_template_parm_scopes > n_class_scopes + 1)
 811     /* We've got too many template headers.  For example:
 812
 813          template <> template <class T> void f (T);
 814
 815        There need to be more enclosing classes.  */
 816     return tsk_excessive_parms;
 817   else
 818     /* This must be a template.  It's of the form:
 819
 820          template <class T> template <class U> void S<T>::f(U);
 821
 822        This is a specialization if the innermost level was a
 823        specialization; otherwise it's just a definition of the
 824        template.  */
 825     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 826 }
 827
 828 void
 829 set_class_shadows (shadows)
 830      tree shadows;
 831 {
 832   class_binding_level->class_shadowed = shadows;
 833 }
 834
 835 /* Enter a new binding level.
 836    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 837    not for that of tags.  */
 838
 839 void
 840 pushlevel (tag_transparent)
 841      int tag_transparent;
 842 {
 843   struct binding_level *newlevel;
 844
 845   if (cfun && !doing_semantic_analysis_p ())
 846     return;
 847
 848   /* Reuse or create a struct for this binding level.  */
 849 #if defined(DEBUG_CP_BINDING_LEVELS)
 850   if (0)
 851 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 852   if (free_binding_level)
 853 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 854     {
 855       newlevel = free_binding_level;
 856       free_binding_level = free_binding_level->level_chain;
 857     }
 858   else
 859     newlevel = make_binding_level ();
 860
 861   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 862   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 863   keep_next_level_flag = 0;
 864 }
 865
 866 /* Enter a new scope.  The KIND indicates what kind of scope is being
 867    created.  */
 868
 869 void
 870 begin_scope (sk)
 871      scope_kind sk;
 872 {
 873   pushlevel (0);
 874
 875   switch (sk)
 876     {
 877     case sk_template_spec:
 878       current_binding_level->template_spec_p = 1;
 879       /* Fall through.  */
 880
 881     case sk_template_parms:
 882       current_binding_level->template_parms_p = 1;
 883       break;
 884
 885     default:
 886       my_friendly_abort (20000309);
 887     }
 888 }
 889
 890 /* Exit the current scope.  */
 891
 892 void
 893 finish_scope ()
 894 {
 895   poplevel (0, 0, 0);
 896 }
 897
 898 void
 899 note_level_for_for ()
 900 {
 901   current_binding_level->is_for_scope = 1;
 902 }
 903
 904 /* Record that the current binding level represents a try block.  */
 905
 906 void
 907 note_level_for_eh ()
 908 {
 909   current_binding_level->eh_region = 1;
 910 }
 911
 912 /* For a binding between a name and an entity at a block scope,
 913    this is the `struct binding_level' for the block.  */
 914 #define BINDING_LEVEL(NODE) \
 915    (((struct tree_binding*)NODE)->scope.level)
 916
 917 /* A free list of CPLUS_BINDING nodes, connected by their
 918    TREE_CHAINs.  */
 919
 920 static tree free_bindings;
 921
 922 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 923    level at which this declaration is being bound.  */
 924
 925 static void
 926 push_binding (id, decl, level)
 927      tree id;
 928      tree decl;
 929      struct binding_level* level;
 930 {
 931   tree binding;
 932
 933   if (free_bindings)
 934     {
 935       binding = free_bindings;
 936       free_bindings = TREE_CHAIN (binding);
 937     }
 938   else
 939     binding = make_node (CPLUS_BINDING);
 940
 941   /* Now, fill in the binding information.  */
 942   BINDING_VALUE (binding) = decl;
 943   BINDING_TYPE (binding) = NULL_TREE;
 944   BINDING_LEVEL (binding) = level;
 945   INHERITED_VALUE_BINDING_P (binding) = 0;
 946   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 947   BINDING_HAS_LEVEL_P (binding) = 1;
 948
 949   /* And put it on the front of the list of bindings for ID.  */
 950   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 951   IDENTIFIER_BINDING (id) = binding;
 952 }
 953
 954 /* ID is already bound in the current scope.  But, DECL is an
 955    additional binding for ID in the same scope.  This is the `struct
 956    stat' hack whereby a non-typedef class-name or enum-name can be
 957    bound at the same level as some other kind of entity.  It's the
 958    responsibility of the caller to check that inserting this name is
 959    legal here.  Returns nonzero if the new binding was successful.  */
 960 static int
 961 add_binding (id, decl)
 962      tree id;
 963      tree decl;
 964 {
 965   tree binding = IDENTIFIER_BINDING (id);
 966   int ok = 1;
 967
 968   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 969     /* The new name is the type name.  */
 970     BINDING_TYPE (binding) = decl;
 971   else if (!BINDING_VALUE (binding))
 972     /* This situation arises when push_class_level_binding moves an
 973        inherited type-binding out of the way to make room for a new
 974        value binding.  */
 975     BINDING_VALUE (binding) = decl;
 976   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 977            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 978     {
 979       /* The old binding was a type name.  It was placed in
 980          BINDING_VALUE because it was thought, at the point it was
 981          declared, to be the only entity with such a name.  Move the
 982          type name into the type slot; it is now hidden by the new
 983          binding.  */
 984       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 985       BINDING_VALUE (binding) = decl;
 986       INHERITED_VALUE_BINDING_P (binding) = 0;
 987     }
 988   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 989            && TREE_CODE (decl) == TYPE_DECL
 990            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 991            && same_type_p (TREE_TYPE (decl),
 992                            TREE_TYPE (BINDING_VALUE (binding))))
 993     /* We have two typedef-names, both naming the same type to have
 994        the same name.  This is OK because of:
 995
 996          [dcl.typedef]
 997
 998          In a given scope, a typedef specifier can be used to redefine
 999          the name of any type declared in that scope to refer to the
1000          type to which it already refers.  */
1001     ok = 0;
1002   /* There can be two block-scope declarations of the same variable,
1003      so long as they are `extern' declarations.  */
1004   else if (TREE_CODE (decl) == VAR_DECL
1005            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1006            && DECL_EXTERNAL (decl)
1007            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1008     {
1009       duplicate_decls (decl, BINDING_VALUE (binding));
1010       ok = 0;
1011     }
1012   else
1013     {
1014       cp_error ("declaration of `%#D'", decl);
1015       cp_error_at ("conflicts with previous declaration `%#D'",
1016                    BINDING_VALUE (binding));
1017       ok = 0;
1018     }
1019
1020   return ok;
1021 }
1022
1023 /* Add DECL to the list of things declared in B.  */
1024
1025 static void
1026 add_decl_to_level (decl, b)
1027      tree decl;
1028      struct binding_level *b;
1029 {
1030   /* We build up the list in reverse order, and reverse it later if
1031      necessary.  */
1032   TREE_CHAIN (decl) = b->names;
1033   b->names = decl;
1034 }
1035
1036 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1037    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1038    doesn't really belong to this binding level, that it got here
1039    through a using-declaration.  */
1040
1041 void
1042 push_local_binding (id, decl, flags)
1043      tree id;
1044      tree decl;
1045      int flags;
1046 {
1047   struct binding_level *b;
1048
1049   /* Skip over any local classes.  This makes sense if we call
1050      push_local_binding with a friend decl of a local class.  */
1051   b = current_binding_level;
1052   while (b->parm_flag == 2)
1053     b = b->level_chain;
1054
1055   if (lookup_name_current_level (id))
1056     {
1057       /* Supplement the existing binding.  */
1058       if (!add_binding (id, decl))
1059         /* It didn't work.  Something else must be bound at this
1060            level.  Do not add DECL to the list of things to pop
1061            later.  */
1062         return;
1063     }
1064   else
1065     /* Create a new binding.  */
1066     push_binding (id, decl, b);
1067
1068   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1069     /* We must put the OVERLOAD into a TREE_LIST since the
1070        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1071        decls that got here through a using-declaration.  */
1072     decl = build_tree_list (NULL_TREE, decl);
1073
1074   /* And put DECL on the list of things declared by the current
1075      binding level.  */
1076   add_decl_to_level (decl, b);
1077 }
1078
1079 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1080    binding was successful.  */
1081
1082 int
1083 push_class_binding (id, decl)
1084      tree id;
1085      tree decl;
1086 {
1087   int result = 1;
1088   tree binding = IDENTIFIER_BINDING (id);
1089   tree context;
1090
1091   /* Note that we declared this value so that we can issue an error if
1092      this an illegal redeclaration of a name already used for some
1093      other purpose.  */
1094   note_name_declared_in_class (id, decl);
1095
1096   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1097     /* Supplement the existing binding.  */
1098     result = add_binding (id, decl);
1099   else
1100     /* Create a new binding.  */
1101     push_binding (id, decl, class_binding_level);
1102
1103   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1104      class-level declaration.  Note that we do not use DECL here
1105      because of the possibility of the `struct stat' hack; if DECL is
1106      a class-name or enum-name we might prefer a field-name, or some
1107      such.  */
1108   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1109
1110   /* If this is a binding from a base class, mark it as such.  */
1111   binding = IDENTIFIER_BINDING (id);
1112   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1113     {
1114       /* Any implicit typename must be from a base-class.  The
1115          context for an implicit typename declaration is always
1116          the derived class in which the lookup was done, so the checks
1117          based on the context of DECL below will not trigger.  */
1118       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1119         INHERITED_VALUE_BINDING_P (binding) = 1;
1120       else
1121         {
1122           if (TREE_CODE (decl) == OVERLOAD)
1123             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1124           else
1125             {
1126               my_friendly_assert (DECL_P (decl), 0);
1127               context = CP_DECL_CONTEXT (decl);
1128             }
1129
1130           if (is_properly_derived_from (current_class_type, context))
1131             INHERITED_VALUE_BINDING_P (binding) = 1;
1132           else
1133             INHERITED_VALUE_BINDING_P (binding) = 0;
1134         }
1135     }
1136   else if (BINDING_VALUE (binding) == decl)
1137     /* We only encounter a TREE_LIST when push_class_decls detects an
1138        ambiguity.  Such an ambiguity can be overridden by a definition
1139        in this class.  */
1140     INHERITED_VALUE_BINDING_P (binding) = 1;
1141
1142   return result;
1143 }
1144
1145 /* Remove the binding for DECL which should be the innermost binding
1146    for ID.  */
1147
1148 static void
1149 pop_binding (id, decl)
1150      tree id;
1151      tree decl;
1152 {
1153   tree binding;
1154
1155   if (id == NULL_TREE)
1156     /* It's easiest to write the loops that call this function without
1157        checking whether or not the entities involved have names.  We
1158        get here for such an entity.  */
1159     return;
1160
1161   /* Get the innermost binding for ID.  */
1162   binding = IDENTIFIER_BINDING (id);
1163
1164   /* The name should be bound.  */
1165   my_friendly_assert (binding != NULL_TREE, 0);
1166
1167   /* The DECL will be either the ordinary binding or the type
1168      binding for this identifier.  Remove that binding.  */
1169   if (BINDING_VALUE (binding) == decl)
1170     BINDING_VALUE (binding) = NULL_TREE;
1171   else if (BINDING_TYPE (binding) == decl)
1172     BINDING_TYPE (binding) = NULL_TREE;
1173   else
1174     my_friendly_abort (0);
1175
1176   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1177     {
1178       /* We're completely done with the innermost binding for this
1179          identifier.  Unhook it from the list of bindings.  */
1180       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1181
1182       /* Add it to the free list.  */
1183       TREE_CHAIN (binding) = free_bindings;
1184       free_bindings = binding;
1185
1186       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1187          it.  */
1188       BINDING_LEVEL (binding) = NULL;
1189     }
1190 }
1191
1192 /* When a label goes out of scope, check to see if that label was used
1193    in a valid manner, and issue any appropriate warnings or errors.  */
1194
1195 static void
1196 pop_label (label, old_value)
1197      tree label;
1198      tree old_value;
1199 {
1200   if (!processing_template_decl && doing_semantic_analysis_p ())
1201     {
1202       if (DECL_INITIAL (label) == NULL_TREE)
1203         {
1204           cp_error_at ("label `%D' used but not defined", label);
1205           /* Avoid crashing later.  */
1206           define_label (input_filename, 1, DECL_NAME (label));
1207         }
1208       else if (warn_unused_label && !TREE_USED (label))
1209         cp_warning_at ("label `%D' defined but not used", label);
1210     }
1211
1212   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1213 }
1214
1215 /* At the end of a function, all labels declared within the function
1216    go out of scope.  BLOCK is the top-level block for the
1217    function.  */
1218
1219 static void
1220 pop_labels (block)
1221      tree block;
1222 {
1223   struct named_label_list *link;
1224
1225   /* Clear out the definitions of all label names, since their scopes
1226      end here.  */
1227   for (link = named_labels; link; link = link->next)
1228     {
1229       pop_label (link->label_decl, link->old_value);
1230       /* Put the labels into the "variables" of the top-level block,
1231          so debugger can see them.  */
1232       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1233       BLOCK_VARS (block) = link->label_decl;
1234     }
1235
1236   named_labels = NULL;
1237 }
1238
1239 /* Exit a binding level.
1240    Pop the level off, and restore the state of the identifier-decl mappings
1241    that were in effect when this level was entered.
1242
1243    If KEEP == 1, this level had explicit declarations, so
1244    and create a "block" (a BLOCK node) for the level
1245    to record its declarations and subblocks for symbol table output.
1246
1247    If FUNCTIONBODY is nonzero, this level is the body of a function,
1248    so create a block as if KEEP were set and also clear out all
1249    label names.
1250
1251    If REVERSE is nonzero, reverse the order of decls before putting
1252    them into the BLOCK.  */
1253
1254 tree
1255 poplevel (keep, reverse, functionbody)
1256      int keep;
1257      int reverse;
1258      int functionbody;
1259 {
1260   register tree link;
1261   /* The chain of decls was accumulated in reverse order.
1262      Put it into forward order, just for cleanliness.  */
1263   tree decls;
1264   int tmp = functionbody;
1265   int real_functionbody;
1266   tree tags;
1267   tree subblocks;
1268   tree block = NULL_TREE;
1269   tree decl;
1270   int leaving_for_scope;
1271
1272   if (cfun && !doing_semantic_analysis_p ())
1273     return NULL_TREE;
1274
1275   my_friendly_assert (current_binding_level->parm_flag != 2,
1276                       19990916);
1277
1278   real_functionbody = (current_binding_level->keep == 2
1279                        ? ((functionbody = 0), tmp) : functionbody);
1280   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1281   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1282
1283   my_friendly_assert (!current_binding_level->class_shadowed,
1284                       19990414);
1285
1286   /* We used to use KEEP == 2 to indicate that the new block should go
1287      at the beginning of the list of blocks at this binding level,
1288      rather than the end.  This hack is no longer used.  */
1289   my_friendly_assert (keep == 0 || keep == 1, 0);
1290
1291   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1292                       (HOST_WIDE_INT) current_binding_level->level_chain,
1293                       current_binding_level->parm_flag,
1294                       current_binding_level->keep);
1295
1296   if (current_binding_level->keep == 1)
1297     keep = 1;
1298
1299   /* Any uses of undefined labels, and any defined labels, now operate
1300      under constraints of next binding contour.  */
1301   if (cfun && !functionbody)
1302     {
1303       struct binding_level *level_chain;
1304       level_chain = current_binding_level->level_chain;
1305       if (level_chain)
1306         {
1307           struct named_label_use_list *uses;
1308           struct named_label_list *labels;
1309           for (labels = named_labels; labels; labels = labels->next)
1310             if (labels->binding_level == current_binding_level)
1311               {
1312                 tree decl;
1313                 if (current_binding_level->eh_region)
1314                   labels->eh_region = 1;
1315                 for (decl = labels->names_in_scope; decl;
1316                      decl = TREE_CHAIN (decl))
1317                   if (decl_jump_unsafe (decl))
1318                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1319                                                    labels->bad_decls);
1320                 labels->binding_level = level_chain;
1321                 labels->names_in_scope = level_chain->names;
1322               }
1323
1324           for (uses = named_label_uses; uses; uses = uses->next)
1325             if (uses->binding_level == current_binding_level)
1326               {
1327                 uses->binding_level = level_chain;
1328                 uses->names_in_scope = level_chain->names;
1329               }
1330         }
1331     }
1332
1333   /* Get the decls in the order they were written.
1334      Usually current_binding_level->names is in reverse order.
1335      But parameter decls were previously put in forward order.  */
1336
1337   if (reverse)
1338     current_binding_level->names
1339       = decls = nreverse (current_binding_level->names);
1340   else
1341     decls = current_binding_level->names;
1342
1343   /* Output any nested inline functions within this block
1344      if they weren't already output.  */
1345   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1346     if (TREE_CODE (decl) == FUNCTION_DECL
1347         && ! TREE_ASM_WRITTEN (decl)
1348         && DECL_INITIAL (decl) != NULL_TREE
1349         && TREE_ADDRESSABLE (decl)
1350         && decl_function_context (decl) == current_function_decl)
1351       {
1352         /* If this decl was copied from a file-scope decl
1353            on account of a block-scope extern decl,
1354            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1355         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1356           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1357         else
1358           {
1359             push_function_context ();
1360             output_inline_function (decl);
1361             pop_function_context ();
1362           }
1363       }
1364
1365   /* When not in function-at-a-time mode, expand_end_bindings will
1366      warn about unused variables.  But, in function-at-a-time mode
1367      expand_end_bindings is not passed the list of variables in the
1368      current scope, and therefore no warning is emitted.  So, we
1369      explicitly warn here.  */
1370   if (!processing_template_decl)
1371     warn_about_unused_variables (getdecls ());
1372
1373   /* If there were any declarations or structure tags in that level,
1374      or if this level is a function body,
1375      create a BLOCK to record them for the life of this function.  */
1376   block = NULL_TREE;
1377   if (keep == 1 || functionbody)
1378     block = make_node (BLOCK);
1379   if (block != NULL_TREE)
1380     {
1381       BLOCK_VARS (block) = decls;
1382       BLOCK_SUBBLOCKS (block) = subblocks;
1383     }
1384
1385   /* In each subblock, record that this is its superior.  */
1386   if (keep >= 0)
1387     for (link = subblocks; link; link = TREE_CHAIN (link))
1388       BLOCK_SUPERCONTEXT (link) = block;
1389
1390   /* We still support the old for-scope rules, whereby the variables
1391      in a for-init statement were in scope after the for-statement
1392      ended.  We only use the new rules in flag_new_for_scope is
1393      nonzero.  */
1394   leaving_for_scope
1395     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1396
1397   /* Remove declarations for all the DECLs in this level.  */
1398   for (link = decls; link; link = TREE_CHAIN (link))
1399     {
1400       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1401           && DECL_NAME (link))
1402         {
1403           tree outer_binding
1404             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1405           tree ns_binding;
1406
1407           if (!outer_binding)
1408             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1409           else
1410             ns_binding = NULL_TREE;
1411
1412           if (outer_binding
1413               && (BINDING_LEVEL (outer_binding)
1414                   == current_binding_level->level_chain))
1415             /* We have something like:
1416
1417                  int i;
1418                  for (int i; ;);
1419
1420                and we are leaving the `for' scope.  There's no reason to
1421                keep the binding of the inner `i' in this case.  */
1422             pop_binding (DECL_NAME (link), link);
1423           else if ((outer_binding
1424                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1425                         == TYPE_DECL))
1426                    || (ns_binding
1427                        && TREE_CODE (ns_binding) == TYPE_DECL))
1428             /* Here, we have something like:
1429
1430                  typedef int I;
1431
1432                  void f () {
1433                    for (int I; ;);
1434                  }
1435
1436                We must pop the for-scope binding so we know what's a
1437                type and what isn't.  */
1438             pop_binding (DECL_NAME (link), link);
1439           else
1440             {
1441               /* Mark this VAR_DECL as dead so that we can tell we left it
1442                  there only for backward compatibility.  */
1443               DECL_DEAD_FOR_LOCAL (link) = 1;
1444
1445               /* Keep track of what should of have happenned when we
1446                  popped the binding.  */
1447               if (outer_binding && BINDING_VALUE (outer_binding))
1448                 DECL_SHADOWED_FOR_VAR (link)
1449                   = BINDING_VALUE (outer_binding);
1450
1451               /* Add it to the list of dead variables in the next
1452                  outermost binding to that we can remove these when we
1453                  leave that binding.  */
1454               current_binding_level->level_chain->dead_vars_from_for
1455                 = tree_cons (NULL_TREE, link,
1456                              current_binding_level->level_chain->
1457                              dead_vars_from_for);
1458
1459               /* Although we don't pop the CPLUS_BINDING, we do clear
1460                  its BINDING_LEVEL since the level is going away now.  */
1461               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1462                 = 0;
1463             }
1464         }
1465       else
1466         {
1467           /* Remove the binding.  */
1468           decl = link;
1469           if (TREE_CODE (decl) == TREE_LIST)
1470             decl = TREE_VALUE (decl);
1471           if (DECL_P (decl))
1472             pop_binding (DECL_NAME (decl), decl);
1473           else if (TREE_CODE (decl) == OVERLOAD)
1474             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1475           else
1476             my_friendly_abort (0);
1477         }
1478     }
1479
1480   /* Remove declarations for any `for' variables from inner scopes
1481      that we kept around.  */
1482   for (link = current_binding_level->dead_vars_from_for;
1483        link; link = TREE_CHAIN (link))
1484     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1485
1486   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1487   for (link = current_binding_level->type_shadowed;
1488        link; link = TREE_CHAIN (link))
1489     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1490
1491   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1492   for (link = current_binding_level->shadowed_labels;
1493        link;
1494        link = TREE_CHAIN (link))
1495     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1496
1497   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1498      list if a `using' declaration put them there.  The debugging
1499      back-ends won't understand OVERLOAD, so we remove them here.
1500      Because the BLOCK_VARS are (temporarily) shared with
1501      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1502      popped all the bindings.  */
1503   if (block)
1504     {
1505       tree* d;
1506
1507       for (d = &BLOCK_VARS (block); *d; )
1508         {
1509           if (TREE_CODE (*d) == TREE_LIST)
1510             *d = TREE_CHAIN (*d);
1511           else
1512             d = &TREE_CHAIN (*d);
1513         }
1514     }
1515
1516   /* If the level being exited is the top level of a function,
1517      check over all the labels.  */
1518   if (functionbody)
1519     {
1520       /* Since this is the top level block of a function, the vars are
1521          the function's parameters.  Don't leave them in the BLOCK
1522          because they are found in the FUNCTION_DECL instead.  */
1523       BLOCK_VARS (block) = 0;
1524       pop_labels (block);
1525     }
1526
1527   tmp = current_binding_level->keep;
1528
1529   pop_binding_level ();
1530   if (functionbody)
1531     DECL_INITIAL (current_function_decl) = block;
1532   else if (block)
1533     current_binding_level->blocks
1534       = chainon (current_binding_level->blocks, block);
1535
1536   /* If we did not make a block for the level just exited,
1537      any blocks made for inner levels
1538      (since they cannot be recorded as subblocks in that level)
1539      must be carried forward so they will later become subblocks
1540      of something else.  */
1541   else if (subblocks)
1542     current_binding_level->blocks
1543       = chainon (current_binding_level->blocks, subblocks);
1544
1545   /* Each and every BLOCK node created here in `poplevel' is important
1546      (e.g. for proper debugging information) so if we created one
1547      earlier, mark it as "used".  */
1548   if (block)
1549     TREE_USED (block) = 1;
1550
1551   /* Take care of compiler's internal binding structures.  */
1552   if (tmp == 2)
1553     {
1554       tree scope_stmts;
1555
1556       scope_stmts
1557         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1558       if (block)
1559         {
1560           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1561           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1562         }
1563
1564       block = poplevel (keep, reverse, functionbody);
1565     }
1566
1567   return block;
1568 }
1569
1570 /* Delete the node BLOCK from the current binding level.
1571    This is used for the block inside a stmt expr ({...})
1572    so that the block can be reinserted where appropriate.  */
1573
1574 void
1575 delete_block (block)
1576      tree block;
1577 {
1578   tree t;
1579   if (current_binding_level->blocks == block)
1580     current_binding_level->blocks = TREE_CHAIN (block);
1581   for (t = current_binding_level->blocks; t;)
1582     {
1583       if (TREE_CHAIN (t) == block)
1584         TREE_CHAIN (t) = TREE_CHAIN (block);
1585       else
1586         t = TREE_CHAIN (t);
1587     }
1588   TREE_CHAIN (block) = NULL_TREE;
1589   /* Clear TREE_USED which is always set by poplevel.
1590      The flag is set again if insert_block is called.  */
1591   TREE_USED (block) = 0;
1592 }
1593
1594 /* Insert BLOCK at the end of the list of subblocks of the
1595    current binding level.  This is used when a BIND_EXPR is expanded,
1596    to handle the BLOCK node inside the BIND_EXPR.  */
1597
1598 void
1599 insert_block (block)
1600      tree block;
1601 {
1602   TREE_USED (block) = 1;
1603   current_binding_level->blocks
1604     = chainon (current_binding_level->blocks, block);
1605 }
1606
1607 /* Set the BLOCK node for the innermost scope
1608    (the one we are currently in).  */
1609
1610 void
1611 set_block (block)
1612     tree block ATTRIBUTE_UNUSED;
1613 {
1614   /* The RTL expansion machinery requires us to provide this callback,
1615      but it is not applicable in function-at-a-time mode.  */
1616   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1617 }
1618
1619 /* Do a pushlevel for class declarations.  */
1620
1621 void
1622 pushlevel_class ()
1623 {
1624   register struct binding_level *newlevel;
1625
1626   /* Reuse or create a struct for this binding level.  */
1627 #if defined(DEBUG_CP_BINDING_LEVELS)
1628   if (0)
1629 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1630   if (free_binding_level)
1631 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1632     {
1633       newlevel = free_binding_level;
1634       free_binding_level = free_binding_level->level_chain;
1635     }
1636   else
1637     newlevel = make_binding_level ();
1638
1639 #if defined(DEBUG_CP_BINDING_LEVELS)
1640   is_class_level = 1;
1641 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1642
1643   push_binding_level (newlevel, 0, 0);
1644
1645   class_binding_level = current_binding_level;
1646   class_binding_level->parm_flag = 2;
1647   class_binding_level->this_class = current_class_type;
1648 }
1649
1650 /* ...and a poplevel for class declarations.  */
1651
1652 void
1653 poplevel_class ()
1654 {
1655   register struct binding_level *level = class_binding_level;
1656   tree shadowed;
1657
1658   my_friendly_assert (level != 0, 354);
1659
1660   /* If we're leaving a toplevel class, don't bother to do the setting
1661      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1662      shouldn't even be used when current_class_type isn't set, and second,
1663      if we don't touch it here, we're able to use the cache effect if the
1664      next time we're entering a class scope, it is the same class.  */
1665   if (current_class_depth != 1)
1666     {
1667       struct binding_level* b;
1668
1669       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1670       for (shadowed = level->class_shadowed;
1671            shadowed;
1672            shadowed = TREE_CHAIN (shadowed))
1673         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1674
1675       /* Find the next enclosing class, and recreate
1676          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1677       b = level->level_chain;
1678       while (b && b->parm_flag != 2)
1679         b = b->level_chain;
1680
1681       if (b)
1682         for (shadowed = b->class_shadowed;
1683              shadowed;
1684              shadowed = TREE_CHAIN (shadowed))
1685           {
1686             tree t;
1687
1688             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1689             while (t && BINDING_LEVEL (t) != b)
1690               t = TREE_CHAIN (t);
1691
1692             if (t)
1693               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1694                 = BINDING_VALUE (t);
1695           }
1696     }
1697   else
1698     /* Remember to save what IDENTIFIER's were bound in this scope so we
1699        can recover from cache misses.  */
1700     {
1701       previous_class_type = current_class_type;
1702       previous_class_values = class_binding_level->class_shadowed;
1703     }
1704   for (shadowed = level->type_shadowed;
1705        shadowed;
1706        shadowed = TREE_CHAIN (shadowed))
1707     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1708
1709   /* Remove the bindings for all of the class-level declarations.  */
1710   for (shadowed = level->class_shadowed;
1711        shadowed;
1712        shadowed = TREE_CHAIN (shadowed))
1713     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1714
1715   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1716                       (HOST_WIDE_INT) class_binding_level->level_chain,
1717                       class_binding_level->parm_flag,
1718                       class_binding_level->keep);
1719
1720   /* Now, pop out of the binding level which we created up in the
1721      `pushlevel_class' routine.  */
1722 #if defined(DEBUG_CP_BINDING_LEVELS)
1723   is_class_level = 1;
1724 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1725
1726   pop_binding_level ();
1727 }
1728
1729 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1730    for any names in enclosing classes.  */
1731
1732 void
1733 clear_identifier_class_values ()
1734 {
1735   tree t;
1736
1737   if (!class_binding_level)
1738     return;
1739
1740   for (t = class_binding_level->class_shadowed;
1741        t;
1742        t = TREE_CHAIN (t))
1743     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1744 }
1745
1746 /* Returns non-zero if T is a virtual function table.  */
1747
1748 int
1749 vtable_decl_p (t, data)
1750      tree t;
1751      void *data ATTRIBUTE_UNUSED;
1752 {
1753   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1754 }
1755
1756 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1757    functions.  */
1758
1759 int
1760 vtype_decl_p (t, data)
1761      tree t;
1762      void *data ATTRIBUTE_UNUSED;
1763 {
1764   return (TREE_CODE (t) == TYPE_DECL
1765           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1766           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1767 }
1768
1769 /* Return the declarations that are members of the namespace NS.  */
1770
1771 tree
1772 cp_namespace_decls (ns)
1773      tree ns;
1774 {
1775   return NAMESPACE_LEVEL (ns)->names;
1776 }
1777
1778 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1779    itself, calling F for each.  The DATA is passed to F as well.  */
1780
1781 static int
1782 walk_namespaces_r (namespace, f, data)
1783      tree namespace;
1784      walk_namespaces_fn f;
1785      void *data;
1786 {
1787   tree current;
1788   int result = 0;
1789
1790   result |= (*f) (namespace, data);
1791
1792   for (current = cp_namespace_decls (namespace);
1793        current;
1794        current = TREE_CHAIN (current))
1795     {
1796       if (TREE_CODE (current) != NAMESPACE_DECL
1797           || DECL_NAMESPACE_ALIAS (current))
1798         continue;
1799       if (!DECL_LANG_SPECIFIC (current))
1800         {
1801           /* Hmm. std. */
1802           my_friendly_assert (current == fake_std_node, 393);
1803           continue;
1804         }
1805
1806       /* We found a namespace.  */
1807       result |= walk_namespaces_r (current, f, data);
1808     }
1809
1810   return result;
1811 }
1812
1813 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1814    F as well.  */
1815
1816 int
1817 walk_namespaces (f, data)
1818      walk_namespaces_fn f;
1819      void *data;
1820 {
1821   return walk_namespaces_r (global_namespace, f, data);
1822 }
1823
1824 struct walk_globals_data {
1825   walk_globals_pred p;
1826   walk_globals_fn f;
1827   void *data;
1828 };
1829
1830 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1831    for which P returns non-zero, call F with its address.  If any call
1832    to F returns a non-zero value, return a non-zero value.  */
1833
1834 static int
1835 walk_globals_r (namespace, data)
1836      tree namespace;
1837      void *data;
1838 {
1839   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1840   walk_globals_pred p = wgd->p;
1841   walk_globals_fn f = wgd->f;
1842   void *d = wgd->data;
1843   tree *t;
1844   int result = 0;
1845
1846   t = &NAMESPACE_LEVEL (namespace)->names;
1847
1848   while (*t)
1849     {
1850       tree glbl = *t;
1851
1852       if ((*p) (glbl, d))
1853         result |= (*f) (t, d);
1854
1855       /* If F changed *T, then *T still points at the next item to
1856          examine.  */
1857       if (*t == glbl)
1858         t = &TREE_CHAIN (*t);
1859     }
1860
1861   return result;
1862 }
1863
1864 /* Walk the global declarations.  Whenever one is found for which P
1865    returns non-zero, call F with its address.  If any call to F
1866    returns a non-zero value, return a non-zero value.  */
1867
1868 int
1869 walk_globals (p, f, data)
1870      walk_globals_pred p;
1871      walk_globals_fn f;
1872      void *data;
1873 {
1874   struct walk_globals_data wgd;
1875   wgd.p = p;
1876   wgd.f = f;
1877   wgd.data = data;
1878
1879   return walk_namespaces (walk_globals_r, &wgd);
1880 }
1881
1882 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1883    DATA is non-NULL, this is the last time we will call
1884    wrapup_global_declarations for this NAMESPACE.  */
1885
1886 int
1887 wrapup_globals_for_namespace (namespace, data)
1888      tree namespace;
1889      void *data;
1890 {
1891   tree globals = cp_namespace_decls (namespace);
1892   int len = list_length (globals);
1893   tree *vec = (tree *) alloca (sizeof (tree) * len);
1894   int i;
1895   int result;
1896   tree decl;
1897   int last_time = (data != 0);
1898
1899   if (last_time && namespace == global_namespace)
1900     /* Let compile_file handle the global namespace.  */
1901     return 0;
1902
1903   /* Process the decls in reverse order--earliest first.
1904      Put them into VEC from back to front, then take out from front.  */
1905   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1906     vec[len - i - 1] = decl;
1907
1908   if (last_time)
1909     {
1910       check_global_declarations (vec, len);
1911       return 0;
1912     }
1913
1914   /* Temporarily mark vtables as external.  That prevents
1915      wrapup_global_declarations from writing them out; we must process
1916      them ourselves in finish_vtable_vardecl.  */
1917   for (i = 0; i < len; ++i)
1918     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1919       {
1920         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1921         DECL_EXTERNAL (vec[i]) = 1;
1922       }
1923
1924   /* Write out any globals that need to be output.  */
1925   result = wrapup_global_declarations (vec, len);
1926
1927   /* Undo the hack to DECL_EXTERNAL above.  */
1928   for (i = 0; i < len; ++i)
1929     if (vtable_decl_p (vec[i], /*data=*/0)
1930         && DECL_NOT_REALLY_EXTERN (vec[i]))
1931       {
1932         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1933         DECL_EXTERNAL (vec[i]) = 0;
1934       }
1935
1936   return result;
1937 }
1938
1939 \f
1940 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1941
1942 static void
1943 mark_binding_level (arg)
1944      void *arg;
1945 {
1946   struct binding_level *lvl = *(struct binding_level **)arg;
1947
1948   for (; lvl; lvl = lvl->level_chain)
1949     {
1950       ggc_mark_tree (lvl->names);
1951       ggc_mark_tree (lvl->tags);
1952       ggc_mark_tree (lvl->usings);
1953       ggc_mark_tree (lvl->using_directives);
1954       ggc_mark_tree (lvl->class_shadowed);
1955       ggc_mark_tree (lvl->type_shadowed);
1956       ggc_mark_tree (lvl->shadowed_labels);
1957       ggc_mark_tree (lvl->blocks);
1958       ggc_mark_tree (lvl->this_class);
1959       ggc_mark_tree (lvl->incomplete);
1960       ggc_mark_tree (lvl->dead_vars_from_for);
1961     }
1962 }
1963
1964 static void
1965 mark_named_label_lists (labs, uses)
1966      void *labs;
1967      void *uses;
1968 {
1969   struct named_label_list *l = *(struct named_label_list **)labs;
1970   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1971
1972   for (; l; l = l->next)
1973     {
1974       ggc_mark (l);
1975       mark_binding_level (l->binding_level);
1976       ggc_mark_tree (l->old_value);
1977       ggc_mark_tree (l->label_decl);
1978       ggc_mark_tree (l->bad_decls);
1979     }
1980
1981   for (; u; u = u->next)
1982     ggc_mark (u);
1983 }
1984 \f
1985 /* For debugging.  */
1986 static int no_print_functions = 0;
1987 static int no_print_builtins = 0;
1988
1989 void
1990 print_binding_level (lvl)
1991      struct binding_level *lvl;
1992 {
1993   tree t;
1994   int i = 0, len;
1995   fprintf (stderr, " blocks=");
1996   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1997   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1998            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1999   if (lvl->tag_transparent)
2000     fprintf (stderr, " tag-transparent");
2001   if (lvl->more_cleanups_ok)
2002     fprintf (stderr, " more-cleanups-ok");
2003   if (lvl->have_cleanups)
2004     fprintf (stderr, " have-cleanups");
2005   fprintf (stderr, "\n");
2006   if (lvl->names)
2007     {
2008       fprintf (stderr, " names:\t");
2009       /* We can probably fit 3 names to a line?  */
2010       for (t = lvl->names; t; t = TREE_CHAIN (t))
2011         {
2012           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2013             continue;
2014           if (no_print_builtins
2015               && (TREE_CODE (t) == TYPE_DECL)
2016               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2017             continue;
2018
2019           /* Function decls tend to have longer names.  */
2020           if (TREE_CODE (t) == FUNCTION_DECL)
2021             len = 3;
2022           else
2023             len = 2;
2024           i += len;
2025           if (i > 6)
2026             {
2027               fprintf (stderr, "\n\t");
2028               i = len;
2029             }
2030           print_node_brief (stderr, "", t, 0);
2031           if (t == error_mark_node)
2032             break;
2033         }
2034       if (i)
2035         fprintf (stderr, "\n");
2036     }
2037   if (lvl->tags)
2038     {
2039       fprintf (stderr, " tags:\t");
2040       i = 0;
2041       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2042         {
2043           if (TREE_PURPOSE (t) == NULL_TREE)
2044             len = 3;
2045           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2046             len = 2;
2047           else
2048             len = 4;
2049           i += len;
2050           if (i > 5)
2051             {
2052               fprintf (stderr, "\n\t");
2053               i = len;
2054             }
2055           if (TREE_PURPOSE (t) == NULL_TREE)
2056             {
2057               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2058               fprintf (stderr, ">");
2059             }
2060           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2061             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2062           else
2063             {
2064               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2065               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2066               fprintf (stderr, ">");
2067             }
2068         }
2069       if (i)
2070         fprintf (stderr, "\n");
2071     }
2072   if (lvl->class_shadowed)
2073     {
2074       fprintf (stderr, " class-shadowed:");
2075       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2076         {
2077           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2078         }
2079       fprintf (stderr, "\n");
2080     }
2081   if (lvl->type_shadowed)
2082     {
2083       fprintf (stderr, " type-shadowed:");
2084       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2085         {
2086           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2087         }
2088       fprintf (stderr, "\n");
2089     }
2090 }
2091
2092 void
2093 print_other_binding_stack (stack)
2094      struct binding_level *stack;
2095 {
2096   struct binding_level *level;
2097   for (level = stack; level != global_binding_level; level = level->level_chain)
2098     {
2099       fprintf (stderr, "binding level ");
2100       fprintf (stderr, HOST_PTR_PRINTF, level);
2101       fprintf (stderr, "\n");
2102       print_binding_level (level);
2103     }
2104 }
2105
2106 void
2107 print_binding_stack ()
2108 {
2109   struct binding_level *b;
2110   fprintf (stderr, "current_binding_level=");
2111   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2112   fprintf (stderr, "\nclass_binding_level=");
2113   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2114   fprintf (stderr, "\nglobal_binding_level=");
2115   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2116   fprintf (stderr, "\n");
2117   if (class_binding_level)
2118     {
2119       for (b = class_binding_level; b; b = b->level_chain)
2120         if (b == current_binding_level)
2121           break;
2122       if (b)
2123         b = class_binding_level;
2124       else
2125         b = current_binding_level;
2126     }
2127   else
2128     b = current_binding_level;
2129   print_other_binding_stack (b);
2130   fprintf (stderr, "global:\n");
2131   print_binding_level (global_binding_level);
2132 }
2133
2134 /* Namespace binding access routines: The namespace_bindings field of
2135    the identifier is polymorphic, with three possible values:
2136    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2137    indicating the BINDING_VALUE of global_namespace. */
2138
2139 /* Check whether the a binding for the name to scope is known.
2140    Assumes that the bindings of the name are already a list
2141    of bindings. Returns the binding found, or NULL_TREE. */
2142
2143 static tree
2144 find_binding (name, scope)
2145      tree name;
2146      tree scope;
2147 {
2148   tree iter, prev = NULL_TREE;
2149
2150   scope = ORIGINAL_NAMESPACE (scope);
2151
2152   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2153        iter = TREE_CHAIN (iter))
2154     {
2155       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2156       if (BINDING_SCOPE (iter) == scope)
2157         {
2158           /* Move binding found to the front of the list, so
2159              subsequent lookups will find it faster. */
2160           if (prev)
2161             {
2162               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2163               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2164               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2165             }
2166           return iter;
2167         }
2168       prev = iter;
2169     }
2170   return NULL_TREE;
2171 }
2172
2173 /* Always returns a binding for name in scope. If the
2174    namespace_bindings is not a list, convert it to one first.
2175    If no binding is found, make a new one. */
2176
2177 tree
2178 binding_for_name (name, scope)
2179      tree name;
2180      tree scope;
2181 {
2182   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2183   tree result;
2184
2185   scope = ORIGINAL_NAMESPACE (scope);
2186
2187   if (b && TREE_CODE (b) != CPLUS_BINDING)
2188     {
2189       /* Get rid of optimization for global scope. */
2190       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2191       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2192       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2193     }
2194   if (b && (result = find_binding (name, scope)))
2195     return result;
2196   /* Not found, make a new one. */
2197   result = make_node (CPLUS_BINDING);
2198   TREE_CHAIN (result) = b;
2199   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2200   BINDING_SCOPE (result) = scope;
2201   BINDING_TYPE (result) = NULL_TREE;
2202   BINDING_VALUE (result) = NULL_TREE;
2203   return result;
2204 }
2205
2206 /* Return the binding value for name in scope, considering that
2207    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2208
2209 tree
2210 namespace_binding (name, scope)
2211      tree name;
2212      tree scope;
2213 {
2214   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2215   if (b == NULL_TREE)
2216     return NULL_TREE;
2217   if (scope == NULL_TREE)
2218     scope = global_namespace;
2219   if (TREE_CODE (b) != CPLUS_BINDING)
2220     return (scope == global_namespace) ? b : NULL_TREE;
2221   name = find_binding (name,scope);
2222   if (name == NULL_TREE)
2223     return name;
2224   return BINDING_VALUE (name);
2225 }
2226
2227 /* Set the binding value for name in scope. If modifying the binding
2228    of global_namespace is attempted, try to optimize it. */
2229
2230 void
2231 set_namespace_binding (name, scope, val)
2232      tree name;
2233      tree scope;
2234      tree val;
2235 {
2236   tree b;
2237
2238   if (scope == NULL_TREE)
2239     scope = global_namespace;
2240
2241   if (scope == global_namespace)
2242     {
2243       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2244       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2245         {
2246           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2247           return;
2248         }
2249     }
2250   b = binding_for_name (name, scope);
2251   BINDING_VALUE (b) = val;
2252 }
2253
2254 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2255    select a name that is unique to this compilation unit.  */
2256
2257 void
2258 push_namespace (name)
2259      tree name;
2260 {
2261   tree d = NULL_TREE;
2262   int need_new = 1;
2263   int implicit_use = 0;
2264   int global = 0;
2265   if (!global_namespace)
2266     {
2267       /* This must be ::. */
2268       my_friendly_assert (name == get_identifier ("::"), 377);
2269       global = 1;
2270     }
2271   else if (!name)
2272     {
2273       /* The name of anonymous namespace is unique for the translation
2274          unit.  */
2275       if (!anonymous_namespace_name)
2276         anonymous_namespace_name = get_file_function_name ('N');
2277       name = anonymous_namespace_name;
2278       d = IDENTIFIER_NAMESPACE_VALUE (name);
2279       if (d)
2280         /* Reopening anonymous namespace.  */
2281         need_new = 0;
2282       implicit_use = 1;
2283     }
2284   else if (current_namespace == global_namespace
2285            && !flag_honor_std
2286            && name == std_identifier)
2287     {
2288       in_fake_std++;
2289       return;
2290     }
2291   else
2292     {
2293       /* Check whether this is an extended namespace definition. */
2294       d = IDENTIFIER_NAMESPACE_VALUE (name);
2295       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2296         {
2297           need_new = 0;
2298           if (DECL_NAMESPACE_ALIAS (d))
2299             {
2300               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2301                         d, DECL_NAMESPACE_ALIAS (d));
2302               d = DECL_NAMESPACE_ALIAS (d);
2303             }
2304         }
2305     }
2306
2307   if (need_new)
2308     {
2309       /* Make a new namespace, binding the name to it. */
2310       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2311       /* The global namespace is not pushed, and the global binding
2312          level is set elsewhere.  */
2313       if (!global)
2314         {
2315           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2316           d = pushdecl (d);
2317           pushlevel (0);
2318           declare_namespace_level ();
2319           NAMESPACE_LEVEL (d) = current_binding_level;
2320         }
2321     }
2322   else
2323     resume_binding_level (NAMESPACE_LEVEL (d));
2324
2325   if (implicit_use)
2326     do_using_directive (d);
2327   /* Enter the name space. */
2328   current_namespace = d;
2329 }
2330
2331 /* Pop from the scope of the current namespace.  */
2332
2333 void
2334 pop_namespace ()
2335 {
2336   if (current_namespace == global_namespace)
2337     {
2338       my_friendly_assert (in_fake_std > 0, 980421);
2339       in_fake_std--;
2340       return;
2341     }
2342   current_namespace = CP_DECL_CONTEXT (current_namespace);
2343   /* The binding level is not popped, as it might be re-opened later.  */
2344   suspend_binding_level ();
2345 }
2346
2347 /* Push into the scope of the namespace NS, even if it is deeply
2348    nested within another namespace.  */
2349
2350 void
2351 push_nested_namespace (ns)
2352      tree ns;
2353 {
2354   if (ns == global_namespace)
2355     push_to_top_level ();
2356   else
2357     {
2358       push_nested_namespace (CP_DECL_CONTEXT (ns));
2359       push_namespace (DECL_NAME (ns));
2360     }
2361 }
2362
2363 /* Pop back from the scope of the namespace NS, which was previously
2364    entered with push_nested_namespace.  */
2365
2366 void
2367 pop_nested_namespace (ns)
2368      tree ns;
2369 {
2370   while (ns != global_namespace)
2371     {
2372       pop_namespace ();
2373       ns = CP_DECL_CONTEXT (ns);
2374     }
2375
2376   pop_from_top_level ();
2377 }
2378
2379 \f
2380 /* Subroutines for reverting temporarily to top-level for instantiation
2381    of templates and such.  We actually need to clear out the class- and
2382    local-value slots of all identifiers, so that only the global values
2383    are at all visible.  Simply setting current_binding_level to the global
2384    scope isn't enough, because more binding levels may be pushed.  */
2385 struct saved_scope *scope_chain;
2386
2387 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2388
2389 static void
2390 mark_saved_scope (arg)
2391      void *arg;
2392 {
2393   struct saved_scope *t = *(struct saved_scope **)arg;
2394   while (t)
2395     {
2396       mark_binding_level (&t->class_bindings);
2397       ggc_mark_tree (t->old_bindings);
2398       ggc_mark_tree (t->old_namespace);
2399       ggc_mark_tree (t->class_name);
2400       ggc_mark_tree (t->class_type);
2401       ggc_mark_tree (t->access_specifier);
2402       ggc_mark_tree (t->function_decl);
2403       if (t->lang_base)
2404         ggc_mark_tree_varray (t->lang_base);
2405       ggc_mark_tree (t->lang_name);
2406       ggc_mark_tree (t->template_parms);
2407       ggc_mark_tree (t->x_previous_class_type);
2408       ggc_mark_tree (t->x_previous_class_values);
2409       ggc_mark_tree (t->x_saved_tree);
2410       ggc_mark_tree (t->incomplete);
2411       ggc_mark_tree (t->lookups);
2412
2413       mark_stmt_tree (&t->x_stmt_tree);
2414       mark_binding_level (&t->bindings);
2415       t = t->prev;
2416     }
2417 }
2418
2419 static tree
2420 store_bindings (names, old_bindings)
2421      tree names, old_bindings;
2422 {
2423   tree t;
2424   tree search_bindings = old_bindings;
2425
2426   for (t = names; t; t = TREE_CHAIN (t))
2427     {
2428       tree binding, t1, id;
2429
2430       if (TREE_CODE (t) == TREE_LIST)
2431         id = TREE_PURPOSE (t);
2432       else
2433         id = DECL_NAME (t);
2434
2435       if (!id
2436           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2437              we have no IDENTIFIER_BINDING if we have left the class
2438              scope, but cached the class-level declarations.  */
2439           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2440         continue;
2441
2442       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2443         if (TREE_VEC_ELT (t1, 0) == id)
2444           goto skip_it;
2445
2446       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2447       binding = make_tree_vec (4);
2448       TREE_VEC_ELT (binding, 0) = id;
2449       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2450       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2451       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2452       IDENTIFIER_BINDING (id) = NULL_TREE;
2453       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2454       TREE_CHAIN (binding) = old_bindings;
2455       old_bindings = binding;
2456     skip_it:
2457       ;
2458     }
2459   return old_bindings;
2460 }
2461
2462 void
2463 maybe_push_to_top_level (pseudo)
2464      int pseudo;
2465 {
2466   struct saved_scope *s;
2467   struct binding_level *b;
2468   tree old_bindings;
2469   int need_pop;
2470
2471   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2472
2473   b = scope_chain ? current_binding_level : 0;
2474
2475   /* If we're in the middle of some function, save our state.  */
2476   if (cfun)
2477     {
2478       need_pop = 1;
2479       push_function_context_to (NULL_TREE);
2480     }
2481   else
2482     need_pop = 0;
2483
2484   old_bindings = NULL_TREE;
2485   if (scope_chain && previous_class_type)
2486     old_bindings = store_bindings (previous_class_values, old_bindings);
2487
2488   /* Have to include global_binding_level, because class-level decls
2489      aren't listed anywhere useful.  */
2490   for (; b; b = b->level_chain)
2491     {
2492       tree t;
2493
2494       /* Template IDs are inserted into the global level. If they were
2495          inserted into namespace level, finish_file wouldn't find them
2496          when doing pending instantiations. Therefore, don't stop at
2497          namespace level, but continue until :: .  */
2498       if (b == global_binding_level || (pseudo && b->template_parms_p))
2499         break;
2500
2501       old_bindings = store_bindings (b->names, old_bindings);
2502       /* We also need to check class_shadowed to save class-level type
2503          bindings, since pushclass doesn't fill in b->names.  */
2504       if (b->parm_flag == 2)
2505         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2506
2507       /* Unwind type-value slots back to top level.  */
2508       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2509         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2510     }
2511   s->prev = scope_chain;
2512   s->old_bindings = old_bindings;
2513   s->bindings = b;
2514   s->need_pop_function_context = need_pop;
2515   s->function_decl = current_function_decl;
2516
2517   scope_chain = s;
2518   current_function_decl = NULL_TREE;
2519   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2520   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2521   current_lang_name = lang_name_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
2548       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2549       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2550       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2551     }
2552
2553   /* If we were in the middle of compiling a function, restore our
2554      state.  */
2555   if (s->need_pop_function_context)
2556     pop_function_context_from (NULL_TREE);
2557   current_function_decl = s->function_decl;
2558
2559   free (s);
2560 }
2561 \f
2562 /* Push a definition of struct, union or enum tag "name".
2563    into binding_level "b".   "type" should be the type node,
2564    We assume that the tag "name" is not already defined.
2565
2566    Note that the definition may really be just a forward reference.
2567    In that case, the TYPE_SIZE will be a NULL_TREE.
2568
2569    C++ gratuitously puts all these tags in the name space.  */
2570
2571 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2572    record the shadowed value for this binding contour.  TYPE is
2573    the type that ID maps to.  */
2574
2575 static void
2576 set_identifier_type_value_with_scope (id, type, b)
2577      tree id;
2578      tree type;
2579      struct binding_level *b;
2580 {
2581   if (!b->namespace_p)
2582     {
2583       /* Shadow the marker, not the real thing, so that the marker
2584          gets restored later. */
2585       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2586       b->type_shadowed
2587         = tree_cons (id, old_type_value, b->type_shadowed);
2588     }
2589   else
2590     {
2591       tree binding = binding_for_name (id, current_namespace);
2592       BINDING_TYPE (binding) = type;
2593       /* Store marker instead of real type. */
2594       type = global_type_node;
2595     }
2596   SET_IDENTIFIER_TYPE_VALUE (id, type);
2597 }
2598
2599 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2600
2601 void
2602 set_identifier_type_value (id, type)
2603      tree id;
2604      tree type;
2605 {
2606   set_identifier_type_value_with_scope (id, type, current_binding_level);
2607 }
2608
2609 /* Return the type associated with id. */
2610
2611 tree
2612 identifier_type_value (id)
2613      tree id;
2614 {
2615   /* There is no type with that name, anywhere. */
2616   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2617     return NULL_TREE;
2618   /* This is not the type marker, but the real thing. */
2619   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2620     return REAL_IDENTIFIER_TYPE_VALUE (id);
2621   /* Have to search for it. It must be on the global level, now.
2622      Ask lookup_name not to return non-types. */
2623   id = lookup_name_real (id, 2, 1, 0);
2624   if (id)
2625     return TREE_TYPE (id);
2626   return NULL_TREE;
2627 }
2628
2629 /* Pop off extraneous binding levels left over due to syntax errors.
2630
2631    We don't pop past namespaces, as they might be valid.  */
2632
2633 void
2634 pop_everything ()
2635 {
2636 #ifdef DEBUG_CP_BINDING_LEVELS
2637   fprintf (stderr, "XXX entering pop_everything ()\n");
2638 #endif
2639   while (!toplevel_bindings_p ())
2640     {
2641       if (current_binding_level->parm_flag == 2)
2642         pop_nested_class ();
2643       else
2644         poplevel (0, 0, 0);
2645     }
2646 #ifdef DEBUG_CP_BINDING_LEVELS
2647   fprintf (stderr, "XXX leaving pop_everything ()\n");
2648 #endif
2649 }
2650
2651 /* The type TYPE is being declared.  If it is a class template, or a
2652    specialization of a class template, do any processing required and
2653    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2654    being declared a friend.  B is the binding level at which this TYPE
2655    should be bound.
2656
2657    Returns the TYPE_DECL for TYPE, which may have been altered by this
2658    processing.  */
2659
2660 static tree
2661 maybe_process_template_type_declaration (type, globalize, b)
2662      tree type;
2663      int globalize;
2664      struct binding_level* b;
2665 {
2666   tree decl = TYPE_NAME (type);
2667
2668   if (processing_template_parmlist)
2669     /* You can't declare a new template type in a template parameter
2670        list.  But, you can declare a non-template type:
2671
2672          template <class A*> struct S;
2673
2674        is a forward-declaration of `A'.  */
2675     ;
2676   else
2677     {
2678       maybe_check_template_type (type);
2679
2680       my_friendly_assert (IS_AGGR_TYPE (type)
2681                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2682
2683
2684       if (processing_template_decl)
2685         {
2686           /* This may change after the call to
2687              push_template_decl_real, but we want the original value.  */
2688           tree name = DECL_NAME (decl);
2689
2690           decl = push_template_decl_real (decl, globalize);
2691           /* If the current binding level is the binding level for the
2692              template parameters (see the comment in
2693              begin_template_parm_list) and the enclosing level is a class
2694              scope, and we're not looking at a friend, push the
2695              declaration of the member class into the class scope.  In the
2696              friend case, push_template_decl will already have put the
2697              friend into global scope, if appropriate.  */
2698           if (TREE_CODE (type) != ENUMERAL_TYPE
2699               && !globalize && b->template_parms_p
2700               && b->level_chain->parm_flag == 2)
2701             {
2702               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2703               /* Put this tag on the list of tags for the class, since
2704                  that won't happen below because B is not the class
2705                  binding level, but is instead the pseudo-global level.  */
2706               b->level_chain->tags =
2707                 tree_cons (name, type, b->level_chain->tags);
2708               if (!COMPLETE_TYPE_P (current_class_type))
2709                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2710             }
2711         }
2712     }
2713
2714   return decl;
2715 }
2716
2717 /* In C++, you don't have to write `struct S' to refer to `S'; you
2718    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2719    if the user had written `typedef struct S S'.  Create and return
2720    the TYPE_DECL for TYPE.  */
2721
2722 tree
2723 create_implicit_typedef (name, type)
2724      tree name;
2725      tree type;
2726 {
2727   tree decl;
2728
2729   decl = build_decl (TYPE_DECL, name, type);
2730   DECL_ARTIFICIAL (decl) = 1;
2731   /* There are other implicit type declarations, like the one *within*
2732      a class that allows you to write `S::S'.  We must distinguish
2733      amongst these.  */
2734   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2735   TYPE_NAME (type) = decl;
2736
2737   return decl;
2738 }
2739
2740 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2741    Normally put it into the inner-most non-tag-transparent scope,
2742    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2743    The latter is needed for implicit declarations.  */
2744
2745 void
2746 pushtag (name, type, globalize)
2747      tree name, type;
2748      int globalize;
2749 {
2750   register struct binding_level *b;
2751
2752   b = current_binding_level;
2753   while (b->tag_transparent
2754          || (globalize && b->parm_flag == 2))
2755     b = b->level_chain;
2756
2757   b->tags = tree_cons (name, type, b->tags);
2758
2759   if (name)
2760     {
2761       /* Do C++ gratuitous typedefing.  */
2762       if (IDENTIFIER_TYPE_VALUE (name) != type)
2763         {
2764           register tree d = NULL_TREE;
2765           int in_class = 0;
2766           tree context = TYPE_CONTEXT (type);
2767
2768           if (! context)
2769             {
2770               tree cs = current_scope ();
2771
2772               if (! globalize)
2773                 context = cs;
2774               else if (cs != NULL_TREE && TYPE_P (cs))
2775                 /* When declaring a friend class of a local class, we want
2776                    to inject the newly named class into the scope
2777                    containing the local class, not the namespace scope.  */
2778                 context = decl_function_context (get_type_decl (cs));
2779             }
2780           if (!context)
2781             context = current_namespace;
2782
2783           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2784               || b->parm_flag == 2)
2785             in_class = 1;
2786
2787           if (current_lang_name == lang_name_java)
2788             TYPE_FOR_JAVA (type) = 1;
2789
2790           d = create_implicit_typedef (name, type);
2791           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2792           if (! in_class)
2793             set_identifier_type_value_with_scope (name, type, b);
2794
2795           d = maybe_process_template_type_declaration (type,
2796                                                        globalize, b);
2797
2798           if (b->parm_flag == 2)
2799             {
2800               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2801                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2802                    class.  But if it's a member template class, we
2803                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2804                    is done later.  */
2805                 finish_member_declaration (d);
2806               else
2807                 pushdecl_class_level (d);
2808             }
2809           else
2810             d = pushdecl_with_scope (d, b);
2811
2812           if (ANON_AGGRNAME_P (name))
2813             DECL_IGNORED_P (d) = 1;
2814
2815           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2816           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2817
2818           /* If this is a local class, keep track of it.  We need this
2819              information for name-mangling, and so that it is possible to find
2820              all function definitions in a translation unit in a convenient
2821              way.  (It's otherwise tricky to find a member function definition
2822              it's only pointed to from within a local class.)  */
2823           if (TYPE_CONTEXT (type)
2824               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2825               && !processing_template_decl)
2826             VARRAY_PUSH_TREE (local_classes, type);
2827
2828           if (!uses_template_parms (type))
2829             {
2830               if (flag_new_abi)
2831                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2832               else
2833                 DECL_ASSEMBLER_NAME (d)
2834                   = get_identifier (build_overload_name (type, 1, 1));
2835             }
2836         }
2837       if (b->parm_flag == 2)
2838         {
2839           if (!COMPLETE_TYPE_P (current_class_type))
2840             CLASSTYPE_TAGS (current_class_type) = b->tags;
2841         }
2842     }
2843
2844   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2845     /* Use the canonical TYPE_DECL for this node.  */
2846     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2847   else
2848     {
2849       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2850          will be the tagged type we just added to the current
2851          binding level.  This fake NULL-named TYPE_DECL node helps
2852          dwarfout.c to know when it needs to output a
2853          representation of a tagged type, and it also gives us a
2854          convenient place to record the "scope start" address for
2855          the tagged type.  */
2856
2857       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2858       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2859     }
2860 }
2861
2862 /* Counter used to create anonymous type names.  */
2863
2864 static int anon_cnt = 0;
2865
2866 /* Return an IDENTIFIER which can be used as a name for
2867    anonymous structs and unions.  */
2868
2869 tree
2870 make_anon_name ()
2871 {
2872   char buf[32];
2873
2874   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2875   return get_identifier (buf);
2876 }
2877
2878 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2879    This keeps dbxout from getting confused.  */
2880
2881 void
2882 clear_anon_tags ()
2883 {
2884   register struct binding_level *b;
2885   register tree tags;
2886   static int last_cnt = 0;
2887
2888   /* Fast out if no new anon names were declared.  */
2889   if (last_cnt == anon_cnt)
2890     return;
2891
2892   b = current_binding_level;
2893   while (b->tag_transparent)
2894     b = b->level_chain;
2895   tags = b->tags;
2896   while (tags)
2897     {
2898       /* A NULL purpose means we have already processed all tags
2899          from here to the end of the list.  */
2900       if (TREE_PURPOSE (tags) == NULL_TREE)
2901         break;
2902       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2903         TREE_PURPOSE (tags) = NULL_TREE;
2904       tags = TREE_CHAIN (tags);
2905     }
2906   last_cnt = anon_cnt;
2907 }
2908 \f
2909 /* Subroutine of duplicate_decls: return truthvalue of whether
2910    or not types of these decls match.
2911
2912    For C++, we must compare the parameter list so that `int' can match
2913    `int&' in a parameter position, but `int&' is not confused with
2914    `const int&'.  */
2915
2916 int
2917 decls_match (newdecl, olddecl)
2918      tree newdecl, olddecl;
2919 {
2920   int types_match;
2921
2922   if (newdecl == olddecl)
2923     return 1;
2924
2925   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2926     /* If the two DECLs are not even the same kind of thing, we're not
2927        interested in their types.  */
2928     return 0;
2929
2930   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2931     {
2932       tree f1 = TREE_TYPE (newdecl);
2933       tree f2 = TREE_TYPE (olddecl);
2934       tree p1 = TYPE_ARG_TYPES (f1);
2935       tree p2 = TYPE_ARG_TYPES (f2);
2936
2937       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2938           && ! (DECL_EXTERN_C_P (newdecl)
2939                 && DECL_EXTERN_C_P (olddecl)))
2940         return 0;
2941
2942       if (TREE_CODE (f1) != TREE_CODE (f2))
2943         return 0;
2944
2945       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2946         {
2947           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2948               && (DECL_BUILT_IN (olddecl)
2949 #ifndef NO_IMPLICIT_EXTERN_C
2950                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2951                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2952 #endif
2953               ))
2954             {
2955               types_match = self_promoting_args_p (p1);
2956               if (p1 == void_list_node)
2957                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2958             }
2959 #ifndef NO_IMPLICIT_EXTERN_C
2960           else if (p1 == NULL_TREE
2961                    && (DECL_EXTERN_C_P (olddecl)
2962                        && DECL_IN_SYSTEM_HEADER (olddecl)
2963                        && !DECL_CLASS_SCOPE_P (olddecl))
2964                    && (DECL_EXTERN_C_P (newdecl)
2965                        && DECL_IN_SYSTEM_HEADER (newdecl)
2966                        && !DECL_CLASS_SCOPE_P (newdecl)))
2967             {
2968               types_match = self_promoting_args_p (p2);
2969               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2970             }
2971 #endif
2972           else
2973             types_match = compparms (p1, p2);
2974         }
2975       else
2976         types_match = 0;
2977     }
2978   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2979     {
2980       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2981                                 DECL_TEMPLATE_PARMS (olddecl)))
2982         return 0;
2983
2984       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2985           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2986         return 0;
2987
2988       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2989         types_match = 1;
2990       else
2991         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2992                                    DECL_TEMPLATE_RESULT (newdecl));
2993     }
2994   else
2995     {
2996       if (TREE_TYPE (newdecl) == error_mark_node)
2997         types_match = TREE_TYPE (olddecl) == error_mark_node;
2998       else if (TREE_TYPE (olddecl) == NULL_TREE)
2999         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3000       else if (TREE_TYPE (newdecl) == NULL_TREE)
3001         types_match = 0;
3002       else
3003         types_match = comptypes (TREE_TYPE (newdecl),
3004                                  TREE_TYPE (olddecl),
3005                                  COMPARE_REDECLARATION);
3006     }
3007
3008   return types_match;
3009 }
3010
3011 /* If NEWDECL is `static' and an `extern' was seen previously,
3012    warn about it.  OLDDECL is the previous declaration.
3013
3014    Note that this does not apply to the C++ case of declaring
3015    a variable `extern const' and then later `const'.
3016
3017    Don't complain about built-in functions, since they are beyond
3018    the user's control.  */
3019
3020 static void
3021 warn_extern_redeclared_static (newdecl, olddecl)
3022      tree newdecl, olddecl;
3023 {
3024   static const char *explicit_extern_static_warning
3025     = "`%D' was declared `extern' and later `static'";
3026   static const char *implicit_extern_static_warning
3027     = "`%D' was declared implicitly `extern' and later `static'";
3028
3029   tree name;
3030
3031   if (TREE_CODE (newdecl) == TYPE_DECL
3032       || TREE_CODE (newdecl) == TEMPLATE_DECL
3033       || TREE_CODE (newdecl) == CONST_DECL)
3034     return;
3035
3036   /* Don't get confused by static member functions; that's a different
3037      use of `static'.  */
3038   if (TREE_CODE (newdecl) == FUNCTION_DECL
3039       && DECL_STATIC_FUNCTION_P (newdecl))
3040     return;
3041
3042   /* If the old declaration was `static', or the new one isn't, then
3043      then everything is OK.  */
3044   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3045     return;
3046
3047   /* It's OK to declare a builtin function as `static'.  */
3048   if (TREE_CODE (olddecl) == FUNCTION_DECL
3049       && DECL_ARTIFICIAL (olddecl))
3050     return;
3051
3052   name = DECL_ASSEMBLER_NAME (newdecl);
3053   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3054               ? implicit_extern_static_warning
3055               : explicit_extern_static_warning, newdecl);
3056   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3057 }
3058
3059 /* Handle when a new declaration NEWDECL has the same name as an old
3060    one OLDDECL in the same binding contour.  Prints an error message
3061    if appropriate.
3062
3063    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3064    Otherwise, return 0.  */
3065
3066 int
3067 duplicate_decls (newdecl, olddecl)
3068      tree newdecl, olddecl;
3069 {
3070   unsigned olddecl_uid = DECL_UID (olddecl);
3071   int olddecl_friend = 0, types_match = 0;
3072   int new_defines_function = 0;
3073
3074   if (newdecl == olddecl)
3075     return 1;
3076
3077   types_match = decls_match (newdecl, olddecl);
3078
3079   /* If either the type of the new decl or the type of the old decl is an
3080      error_mark_node, then that implies that we have already issued an
3081      error (earlier) for some bogus type specification, and in that case,
3082      it is rather pointless to harass the user with yet more error message
3083      about the same declaration, so just pretend the types match here.  */
3084   if (TREE_TYPE (newdecl) == error_mark_node
3085       || TREE_TYPE (olddecl) == error_mark_node)
3086     types_match = 1;
3087
3088   /* Check for redeclaration and other discrepancies. */
3089   if (TREE_CODE (olddecl) == FUNCTION_DECL
3090       && DECL_ARTIFICIAL (olddecl))
3091     {
3092       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3093         {
3094           /* If you declare a built-in or predefined function name as static,
3095              the old definition is overridden, but optionally warn this was a
3096              bad choice of name.  */
3097           if (! TREE_PUBLIC (newdecl))
3098             {
3099               if (warn_shadow)
3100                 cp_warning ("shadowing %s function `%#D'",
3101                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3102                             olddecl);
3103               /* Discard the old built-in function.  */
3104               return 0;
3105             }
3106           /* If the built-in is not ansi, then programs can override
3107              it even globally without an error.  */
3108           else if (! DECL_BUILT_IN (olddecl))
3109             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3110                         olddecl, newdecl);
3111           else
3112             {
3113               cp_error ("declaration of `%#D'", newdecl);
3114               cp_error ("conflicts with built-in declaration `%#D'",
3115                         olddecl);
3116             }
3117           return 0;
3118         }
3119       else if (!types_match)
3120         {
3121           if ((DECL_EXTERN_C_P (newdecl)
3122                && DECL_EXTERN_C_P (olddecl))
3123               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3124                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3125             {
3126               /* A near match; override the builtin.  */
3127
3128               if (TREE_PUBLIC (newdecl))
3129                 {
3130                   cp_warning ("new declaration `%#D'", newdecl);
3131                   cp_warning ("ambiguates built-in declaration `%#D'",
3132                               olddecl);
3133                 }
3134               else if (warn_shadow)
3135                 cp_warning ("shadowing %s function `%#D'",
3136                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3137                             olddecl);
3138             }
3139           else
3140             /* Discard the old built-in function.  */
3141             return 0;
3142         }
3143
3144       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3145         {
3146           /* If a builtin function is redeclared as `static', merge
3147              the declarations, but make the original one static.  */
3148           DECL_THIS_STATIC (olddecl) = 1;
3149           TREE_PUBLIC (olddecl) = 0;
3150
3151           /* Make the old declaration consistent with the new one so
3152              that all remnants of the builtin-ness of this function
3153              will be banished.  */
3154           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3155           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3156           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3157           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3158                                        newdecl);
3159         }
3160     }
3161   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3162     {
3163       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3164            && TREE_CODE (newdecl) != TYPE_DECL
3165            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3166                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3167           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3168               && TREE_CODE (olddecl) != TYPE_DECL
3169               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3170                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3171                         == TYPE_DECL))))
3172         {
3173           /* We do nothing special here, because C++ does such nasty
3174              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3175              get shadowed, and know that if we need to find a TYPE_DECL
3176              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3177              slot of the identifier.  */
3178           return 0;
3179         }
3180
3181       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3182            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3183           || (TREE_CODE (olddecl) == FUNCTION_DECL
3184               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3185         return 0;
3186
3187       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3188       if (TREE_CODE (olddecl) == TREE_LIST)
3189         olddecl = TREE_VALUE (olddecl);
3190       cp_error_at ("previous declaration of `%#D'", olddecl);
3191
3192       /* New decl is completely inconsistent with the old one =>
3193          tell caller to replace the old one.  */
3194
3195       return 0;
3196     }
3197   else if (!types_match)
3198     {
3199       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3200         /* These are certainly not duplicate declarations; they're
3201            from different scopes.  */
3202         return 0;
3203
3204       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3205         {
3206           /* The name of a class template may not be declared to refer to
3207              any other template, class, function, object, namespace, value,
3208              or type in the same scope.  */
3209           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3210               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3211             {
3212               cp_error ("declaration of template `%#D'", newdecl);
3213               cp_error_at ("conflicts with previous declaration `%#D'",
3214                            olddecl);
3215             }
3216           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3217                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3218                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3219                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3220                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3221                                            DECL_TEMPLATE_PARMS (olddecl)))
3222             {
3223               cp_error ("new declaration `%#D'", newdecl);
3224               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3225             }
3226           return 0;
3227         }
3228       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3229         {
3230           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3231             {
3232               cp_error ("declaration of C function `%#D' conflicts with",
3233                         newdecl);
3234               cp_error_at ("previous declaration `%#D' here", olddecl);
3235             }
3236           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3237                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3238             {
3239               cp_error ("new declaration `%#D'", newdecl);
3240               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3241             }
3242           else
3243             return 0;
3244         }
3245
3246       /* Already complained about this, so don't do so again.  */
3247       else if (current_class_type == NULL_TREE
3248           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3249         {
3250           cp_error ("conflicting types for `%#D'", newdecl);
3251           cp_error_at ("previous declaration as `%#D'", olddecl);
3252         }
3253     }
3254   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3255             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3256                  && (!DECL_TEMPLATE_INFO (newdecl)
3257                      || (DECL_TI_TEMPLATE (newdecl)
3258                          != DECL_TI_TEMPLATE (olddecl))))
3259                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3260                     && (!DECL_TEMPLATE_INFO (olddecl)
3261                         || (DECL_TI_TEMPLATE (olddecl)
3262                             != DECL_TI_TEMPLATE (newdecl))))))
3263     /* It's OK to have a template specialization and a non-template
3264        with the same type, or to have specializations of two
3265        different templates with the same type.  Note that if one is a
3266        specialization, and the other is an instantiation of the same
3267        template, that we do not exit at this point.  That situation
3268        can occur if we instantiate a template class, and then
3269        specialize one of its methods.  This situation is legal, but
3270        the declarations must be merged in the usual way.  */
3271     return 0;
3272   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3273            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3274                 && !DECL_USE_TEMPLATE (newdecl))
3275                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3276                    && !DECL_USE_TEMPLATE (olddecl))))
3277     /* One of the declarations is a template instantiation, and the
3278        other is not a template at all.  That's OK.  */
3279     return 0;
3280   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3281            && DECL_NAMESPACE_ALIAS (newdecl)
3282            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3283     /* Redeclaration of namespace alias, ignore it. */
3284     return 1;
3285   else
3286     {
3287       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3288       if (errmsg)
3289         {
3290           cp_error (errmsg, newdecl);
3291           if (DECL_NAME (olddecl) != NULL_TREE)
3292             cp_error_at ((DECL_INITIAL (olddecl)
3293                           && namespace_bindings_p ())
3294                          ? "`%#D' previously defined here"
3295                          : "`%#D' previously declared here", olddecl);
3296         }
3297       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3298                && DECL_INITIAL (olddecl) != NULL_TREE
3299                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3300                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3301         {
3302           /* Prototype decl follows defn w/o prototype.  */
3303           cp_warning_at ("prototype for `%#D'", newdecl);
3304           cp_warning_at ("follows non-prototype definition here", olddecl);
3305         }
3306       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3307                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3308         {
3309           /* extern "C" int foo ();
3310              int foo () { bar (); }
3311              is OK.  */
3312           if (current_lang_stack
3313               == &VARRAY_TREE (current_lang_base, 0))
3314             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3315           else
3316             {
3317               cp_error_at ("previous declaration of `%#D' with %L linkage",
3318                            olddecl, DECL_LANGUAGE (olddecl));
3319               cp_error ("conflicts with new declaration with %L linkage",
3320                         DECL_LANGUAGE (newdecl));
3321             }
3322         }
3323
3324       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3325         ;
3326       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3327         {
3328           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3329           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3330           int i = 1;
3331
3332           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3333             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3334
3335           for (; t1 && t1 != void_list_node;
3336                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3337             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3338               {
3339                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3340                                            TREE_PURPOSE (t2)))
3341                   {
3342                     if (pedantic)
3343                       {
3344                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3345                                     i, newdecl);
3346                         cp_pedwarn_at ("after previous specification in `%#D'",
3347                                        olddecl);
3348                       }
3349                   }
3350                 else
3351                   {
3352                     cp_error ("default argument given for parameter %d of `%#D'",
3353                               i, newdecl);
3354                     cp_error_at ("after previous specification in `%#D'",
3355                                  olddecl);
3356                   }
3357               }
3358
3359           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3360               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3361             {
3362               cp_warning ("`%#D' was used before it was declared inline",
3363                           newdecl);
3364               cp_warning_at ("previous non-inline declaration here",
3365                              olddecl);
3366             }
3367         }
3368     }
3369
3370   /* If new decl is `static' and an `extern' was seen previously,
3371      warn about it.  */
3372   warn_extern_redeclared_static (newdecl, olddecl);
3373
3374   /* We have committed to returning 1 at this point.  */
3375   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3376     {
3377       /* Now that functions must hold information normally held
3378          by field decls, there is extra work to do so that
3379          declaration information does not get destroyed during
3380          definition.  */
3381       if (DECL_VINDEX (olddecl))
3382         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3383       if (DECL_VIRTUAL_CONTEXT (olddecl))
3384         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3385       if (DECL_CONTEXT (olddecl))
3386         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3387       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3388         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3389       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3390       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3391       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3392       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3393       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3394       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3395       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3396       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3397
3398       /* Optionally warn about more than one declaration for the same
3399          name, but don't warn about a function declaration followed by a
3400          definition.  */
3401       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3402           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3403           /* Don't warn about extern decl followed by definition. */
3404           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3405           /* Don't warn about friends, let add_friend take care of it. */
3406           && ! DECL_FRIEND_P (newdecl))
3407         {
3408           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3409           cp_warning_at ("previous declaration of `%D'", olddecl);
3410         }
3411     }
3412
3413   /* Deal with C++: must preserve virtual function table size.  */
3414   if (TREE_CODE (olddecl) == TYPE_DECL)
3415     {
3416       register tree newtype = TREE_TYPE (newdecl);
3417       register tree oldtype = TREE_TYPE (olddecl);
3418
3419       if (newtype != error_mark_node && oldtype != error_mark_node
3420           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3421         {
3422           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3423           CLASSTYPE_FRIEND_CLASSES (newtype)
3424             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3425         }
3426
3427       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3428     }
3429
3430   /* Copy all the DECL_... slots specified in the new decl
3431      except for any that we copy here from the old type.  */
3432   DECL_MACHINE_ATTRIBUTES (newdecl)
3433     = merge_machine_decl_attributes (olddecl, newdecl);
3434
3435   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3436     {
3437       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3438       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3439         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3440                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3441
3442       return 1;
3443     }
3444
3445   if (types_match)
3446     {
3447       /* Automatically handles default parameters.  */
3448       tree oldtype = TREE_TYPE (olddecl);
3449       tree newtype;
3450
3451       /* Merge the data types specified in the two decls.  */
3452       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3453
3454       /* If common_type produces a non-typedef type, just use the old type.  */
3455       if (TREE_CODE (newdecl) == TYPE_DECL
3456           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3457         newtype = oldtype;
3458
3459       if (TREE_CODE (newdecl) == VAR_DECL)
3460         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3461       /* Do this after calling `common_type' so that default
3462          parameters don't confuse us.  */
3463       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3464           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3465               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3466         {
3467           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3468                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3469           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3470                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3471
3472           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3473               && DECL_SOURCE_LINE (olddecl) != 0
3474               && flag_exceptions
3475               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3476                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3477             {
3478               cp_error ("declaration of `%F' throws different exceptions",
3479                         newdecl);
3480               cp_error_at ("than previous declaration `%F'", olddecl);
3481             }
3482         }
3483       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3484
3485       /* Lay the type out, unless already done.  */
3486       if (! same_type_p (newtype, oldtype)
3487           && TREE_TYPE (newdecl) != error_mark_node
3488           && !(processing_template_decl && uses_template_parms (newdecl)))
3489         layout_type (TREE_TYPE (newdecl));
3490
3491       if ((TREE_CODE (newdecl) == VAR_DECL
3492            || TREE_CODE (newdecl) == PARM_DECL
3493            || TREE_CODE (newdecl) == RESULT_DECL
3494            || TREE_CODE (newdecl) == FIELD_DECL
3495            || TREE_CODE (newdecl) == TYPE_DECL)
3496           && !(processing_template_decl && uses_template_parms (newdecl)))
3497         layout_decl (newdecl, 0);
3498
3499       /* Merge the type qualifiers.  */
3500       if (TREE_READONLY (newdecl))
3501         TREE_READONLY (olddecl) = 1;
3502       if (TREE_THIS_VOLATILE (newdecl))
3503         TREE_THIS_VOLATILE (olddecl) = 1;
3504
3505       /* Merge the initialization information.  */
3506       if (DECL_INITIAL (newdecl) == NULL_TREE
3507           && DECL_INITIAL (olddecl) != NULL_TREE)
3508         {
3509           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3510           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3511           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3512           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3513               && DECL_LANG_SPECIFIC (newdecl)
3514               && DECL_LANG_SPECIFIC (olddecl))
3515             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3516         }
3517
3518       /* Merge the section attribute.
3519          We want to issue an error if the sections conflict but that must be
3520          done later in decl_attributes since we are called before attributes
3521          are assigned.  */
3522       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3523         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3524
3525       /* Keep the old rtl since we can safely use it.  */
3526       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3527
3528       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3529         {
3530           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3531             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3532           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3533             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3534           DECL_NO_LIMIT_STACK (newdecl)
3535             |= DECL_NO_LIMIT_STACK (olddecl);
3536         }
3537     }
3538   /* If cannot merge, then use the new type and qualifiers,
3539      and don't preserve the old rtl.  */
3540   else
3541     {
3542       /* Clean out any memory we had of the old declaration.  */
3543       tree oldstatic = value_member (olddecl, static_aggregates);
3544       if (oldstatic)
3545         TREE_VALUE (oldstatic) = error_mark_node;
3546
3547       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3548       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3549       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3550       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3551     }
3552
3553   /* Merge the storage class information.  */
3554   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3555   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3556   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3557   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3558   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3559   if (! DECL_EXTERNAL (olddecl))
3560     DECL_EXTERNAL (newdecl) = 0;
3561
3562   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3563     {
3564       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3565       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3566       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3567       DECL_TEMPLATE_INSTANTIATED (newdecl)
3568         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3569       /* Don't really know how much of the language-specific
3570          values we should copy from old to new.  */
3571       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3572       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3573       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3574       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3575       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3576         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3577       olddecl_friend = DECL_FRIEND_P (olddecl);
3578
3579       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3580       if (TREE_CODE (newdecl) == FUNCTION_DECL
3581           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3582         DECL_BEFRIENDING_CLASSES (newdecl)
3583           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3584                      DECL_BEFRIENDING_CLASSES (olddecl));
3585     }
3586
3587   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3588     {
3589       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3590           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3591         {
3592           /* If newdecl is not a specialization, then it is not a
3593              template-related function at all.  And that means that we
3594              shoud have exited above, returning 0.  */
3595           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3596                               0);
3597
3598           if (TREE_USED (olddecl))
3599             /* From [temp.expl.spec]:
3600
3601                If a template, a member template or the member of a class
3602                template is explicitly specialized then that
3603                specialization shall be declared before the first use of
3604                that specialization that would cause an implicit
3605                instantiation to take place, in every translation unit in
3606                which such a use occurs.  */
3607             cp_error ("explicit specialization of %D after first use",
3608                       olddecl);
3609
3610           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3611         }
3612       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3613
3614       /* If either decl says `inline', this fn is inline, unless its
3615          definition was passed already.  */
3616       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3617         DECL_INLINE (olddecl) = 1;
3618       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3619
3620       if (! types_match)
3621         {
3622           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3623           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3624           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3625         }
3626       if (! types_match || new_defines_function)
3627         {
3628           /* These need to be copied so that the names are available.
3629              Note that if the types do match, we'll preserve inline
3630              info and other bits, but if not, we won't.  */
3631           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3632           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3633         }
3634       if (new_defines_function)
3635         /* If defining a function declared with other language
3636            linkage, use the previously declared language linkage.  */
3637         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3638       else if (types_match)
3639         {
3640           /* If redeclaring a builtin function, and not a definition,
3641              it stays built in.  */
3642           if (DECL_BUILT_IN (olddecl))
3643             {
3644               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3645               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3646               /* If we're keeping the built-in definition, keep the rtl,
3647                  regardless of declaration matches.  */
3648               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3649             }
3650           else
3651             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3652
3653           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3654           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3655             /* Previously saved insns go together with
3656                the function's previous definition.  */
3657             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3658           /* Don't clear out the arguments if we're redefining a function.  */
3659           if (DECL_ARGUMENTS (olddecl))
3660             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3661         }
3662     }
3663
3664   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3665     {
3666       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3667     }
3668
3669   /* Now preserve various other info from the definition.  */
3670   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3671   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3672   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3673   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3674
3675   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3676     {
3677       int function_size;
3678
3679       function_size = sizeof (struct tree_decl);
3680
3681       bcopy ((char *) newdecl + sizeof (struct tree_common),
3682              (char *) olddecl + sizeof (struct tree_common),
3683              function_size - sizeof (struct tree_common));
3684
3685       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3686         {
3687           /* If newdecl is a template instantiation, it is possible that
3688              the following sequence of events has occurred:
3689
3690              o A friend function was declared in a class template.  The
3691              class template was instantiated.
3692
3693              o The instantiation of the friend declaration was
3694              recorded on the instantiation list, and is newdecl.
3695
3696              o Later, however, instantiate_class_template called pushdecl
3697              on the newdecl to perform name injection.  But, pushdecl in
3698              turn called duplicate_decls when it discovered that another
3699              declaration of a global function with the same name already
3700              existed.
3701
3702              o Here, in duplicate_decls, we decided to clobber newdecl.
3703
3704              If we're going to do that, we'd better make sure that
3705              olddecl, and not newdecl, is on the list of
3706              instantiations so that if we try to do the instantiation
3707              again we won't get the clobbered declaration.  */
3708
3709           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3710           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3711
3712           for (; decls; decls = TREE_CHAIN (decls))
3713             if (TREE_VALUE (decls) == newdecl)
3714               TREE_VALUE (decls) = olddecl;
3715         }
3716     }
3717   else
3718     {
3719       bcopy ((char *) newdecl + sizeof (struct tree_common),
3720              (char *) olddecl + sizeof (struct tree_common),
3721              sizeof (struct tree_decl) - sizeof (struct tree_common)
3722              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3723     }
3724
3725   DECL_UID (olddecl) = olddecl_uid;
3726   if (olddecl_friend)
3727     DECL_FRIEND_P (olddecl) = 1;
3728
3729   /* NEWDECL contains the merged attribute lists.
3730      Update OLDDECL to be the same.  */
3731   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3732
3733   return 1;
3734 }
3735
3736 /* Record a decl-node X as belonging to the current lexical scope.
3737    Check for errors (such as an incompatible declaration for the same
3738    name already seen in the same scope).
3739
3740    Returns either X or an old decl for the same name.
3741    If an old decl is returned, it may have been smashed
3742    to agree with what X says.  */
3743
3744 tree
3745 pushdecl (x)
3746      tree x;
3747 {
3748   register tree t;
3749   register tree name;
3750   int need_new_binding;
3751
3752   /* We shouldn't be calling pushdecl when we're generating RTL for a
3753      function that we already did semantic analysis on previously.  */
3754   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3755                       19990913);
3756
3757   need_new_binding = 1;
3758
3759   if (DECL_TEMPLATE_PARM_P (x))
3760     /* Template parameters have no context; they are not X::T even
3761        when declared within a class or namespace.  */
3762     ;
3763   else
3764     {
3765       if (current_function_decl && x != current_function_decl
3766           /* A local declaration for a function doesn't constitute
3767              nesting.  */
3768           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3769           /* A local declaration for an `extern' variable is in the
3770              scope of the current namespace, not the current
3771              function.  */
3772           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3773           && !DECL_CONTEXT (x))
3774         DECL_CONTEXT (x) = current_function_decl;
3775
3776       /* If this is the declaration for a namespace-scope function,
3777          but the declaration itself is in a local scope, mark the
3778          declaration.  */
3779       if (TREE_CODE (x) == FUNCTION_DECL
3780           && DECL_NAMESPACE_SCOPE_P (x)
3781           && current_function_decl
3782           && x != current_function_decl)
3783         DECL_LOCAL_FUNCTION_P (x) = 1;
3784     }
3785
3786   name = DECL_NAME (x);
3787   if (name)
3788     {
3789       int different_binding_level = 0;
3790
3791       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3792         name = TREE_OPERAND (name, 0);
3793
3794       /* In case this decl was explicitly namespace-qualified, look it
3795          up in its namespace context.  */
3796       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3797           && namespace_bindings_p ())
3798         t = namespace_binding (name, DECL_CONTEXT (x));
3799       else
3800         t = lookup_name_current_level (name);
3801
3802       /* [basic.link] If there is a visible declaration of an entity
3803          with linkage having the same name and type, ignoring entities
3804          declared outside the innermost enclosing namespace scope, the
3805          block scope declaration declares that same entity and
3806          receives the linkage of the previous declaration.  */
3807       if (! t && current_function_decl && x != current_function_decl
3808           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3809           && DECL_EXTERNAL (x))
3810         {
3811           /* Look in block scope.  */
3812           t = IDENTIFIER_VALUE (name);
3813           /* Or in the innermost namespace.  */
3814           if (! t)
3815             t = namespace_binding (name, DECL_CONTEXT (x));
3816           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3817              OVERLOAD, which is OK.  */
3818           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3819             t = NULL_TREE;
3820           if (t)
3821             different_binding_level = 1;
3822         }
3823
3824       /* If we are declaring a function, and the result of name-lookup
3825          was an OVERLOAD, look for an overloaded instance that is
3826          actually the same as the function we are declaring.  (If
3827          there is one, we have to merge our declaration with the
3828          previous declaration.)  */
3829       if (t && TREE_CODE (t) == OVERLOAD)
3830         {
3831           tree match;
3832
3833           if (TREE_CODE (x) == FUNCTION_DECL)
3834             for (match = t; match; match = OVL_NEXT (match))
3835               {
3836                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3837                     == DECL_ASSEMBLER_NAME (x))
3838                   break;
3839               }
3840           else
3841             /* Just choose one.  */
3842             match = t;
3843
3844           if (match)
3845             t = OVL_CURRENT (match);
3846           else
3847             t = NULL_TREE;
3848         }
3849
3850       if (t == error_mark_node)
3851         {
3852           /* error_mark_node is 0 for a while during initialization!  */
3853           t = NULL_TREE;
3854           cp_error_at ("`%#D' used prior to declaration", x);
3855         }
3856       else if (t != NULL_TREE)
3857         {
3858           if (different_binding_level)
3859             {
3860               if (decls_match (x, t))
3861                 /* The standard only says that the local extern
3862                    inherits linkage from the previous decl; in
3863                    particular, default args are not shared.  It would
3864                    be nice to propagate inlining info, though.  FIXME.  */
3865                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3866             }
3867           else if (TREE_CODE (t) == PARM_DECL)
3868             {
3869               if (DECL_CONTEXT (t) == NULL_TREE)
3870                 fatal ("parse errors have confused me too much");
3871
3872               /* Check for duplicate params.  */
3873               if (duplicate_decls (x, t))
3874                 return t;
3875             }
3876           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3877                     || DECL_FUNCTION_TEMPLATE_P (x))
3878                    && is_overloaded_fn (t))
3879             /* Don't do anything just yet. */;
3880           else if (t == wchar_decl_node)
3881             {
3882               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3883                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3884
3885               /* Throw away the redeclaration.  */
3886               return t;
3887             }
3888           else if (TREE_CODE (t) != TREE_CODE (x))
3889             {
3890               if (duplicate_decls (x, t))
3891                 return t;
3892             }
3893           else if (duplicate_decls (x, t))
3894             {
3895               if (TREE_CODE (t) == TYPE_DECL)
3896                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3897               else if (TREE_CODE (t) == FUNCTION_DECL)
3898                 check_default_args (t);
3899
3900               return t;
3901             }
3902           else if (DECL_MAIN_P (x))
3903             {
3904               /* A redeclaration of main, but not a duplicate of the
3905                  previous one.
3906
3907                  [basic.start.main]
3908
3909                  This function shall not be overloaded.  */
3910               cp_error_at ("invalid redeclaration of `%D'", t);
3911               cp_error ("as `%D'", x);
3912               /* We don't try to push this declaration since that
3913                  causes a crash.  */
3914               return x;
3915             }
3916         }
3917
3918       check_template_shadow (x);
3919
3920       /* If this is a function conjured up by the backend, massage it
3921          so it looks friendly.  */
3922       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3923         {
3924           retrofit_lang_decl (x);
3925           DECL_LANGUAGE (x) = lang_c;
3926         }
3927
3928       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3929         {
3930           t = push_overloaded_decl (x, PUSH_LOCAL);
3931           if (t != x)
3932             return t;
3933           if (!namespace_bindings_p ())
3934             /* We do not need to create a binding for this name;
3935                push_overloaded_decl will have already done so if
3936                necessary.  */
3937             need_new_binding = 0;
3938         }
3939       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3940         {
3941           t = push_overloaded_decl (x, PUSH_GLOBAL);
3942           if (t == x)
3943             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3944           return t;
3945         }
3946
3947       /* If declaring a type as a typedef, copy the type (unless we're
3948          at line 0), and install this TYPE_DECL as the new type's typedef
3949          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3950       if (TREE_CODE (x) == TYPE_DECL)
3951         {
3952           tree type = TREE_TYPE (x);
3953           if (DECL_SOURCE_LINE (x) == 0)
3954             {
3955               if (TYPE_NAME (type) == 0)
3956                 TYPE_NAME (type) = x;
3957             }
3958           else if (type != error_mark_node && TYPE_NAME (type) != x
3959                    /* We don't want to copy the type when all we're
3960                       doing is making a TYPE_DECL for the purposes of
3961                       inlining.  */
3962                    && (!TYPE_NAME (type)
3963                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3964             {
3965               DECL_ORIGINAL_TYPE (x) = type;
3966               type = build_type_copy (type);
3967               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3968               TYPE_NAME (type) = x;
3969               TREE_TYPE (x) = type;
3970             }
3971
3972           if (type != error_mark_node
3973               && TYPE_NAME (type)
3974               && TYPE_IDENTIFIER (type))
3975             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3976                                                   current_binding_level);
3977
3978         }
3979
3980       /* Multiple external decls of the same identifier ought to match.
3981
3982          We get warnings about inline functions where they are defined.
3983          We get warnings about other functions from push_overloaded_decl.
3984
3985          Avoid duplicate warnings where they are used.  */
3986       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3987         {
3988           tree decl;
3989
3990           decl = IDENTIFIER_NAMESPACE_VALUE (name);
3991           if (decl && TREE_CODE (decl) == OVERLOAD)
3992             decl = OVL_FUNCTION (decl);
3993
3994           if (decl && decl != error_mark_node
3995               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
3996               /* If different sort of thing, we already gave an error.  */
3997               && TREE_CODE (decl) == TREE_CODE (x)
3998               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3999             {
4000               cp_pedwarn ("type mismatch with previous external decl", x);
4001               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4002             }
4003         }
4004
4005       /* This name is new in its binding level.
4006          Install the new declaration and return it.  */
4007       if (namespace_bindings_p ())
4008         {
4009           /* Install a global value.  */
4010
4011           /* If the first global decl has external linkage,
4012              warn if we later see static one.  */
4013           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4014             TREE_PUBLIC (name) = 1;
4015
4016           /* Bind the mangled name for the entity.  In the future, we
4017              should not need to do this; mangled names are an
4018              implementation detail of which the front-end should not
4019              need to be aware.  */
4020           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4021                 && t != NULL_TREE)
4022               /* For an ordinary function, we create a binding from
4023                  the mangled name (i.e., NAME) to the DECL.  But, for
4024                  an `extern "C"' function, the mangled name and the
4025                  ordinary name are the same so we need not do this.  */
4026               && !DECL_EXTERN_C_FUNCTION_P (x))
4027             {
4028               tree mangled_name;
4029
4030               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4031                   || TREE_CODE (x) == NAMESPACE_DECL)
4032                 mangled_name = name;
4033               else
4034                 mangled_name = DECL_ASSEMBLER_NAME (x);
4035
4036               if (TREE_CODE (x) == FUNCTION_DECL)
4037                 my_friendly_assert
4038                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4039                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4040               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4041             }
4042
4043           /* Don't forget if the function was used via an implicit decl.  */
4044           if (IDENTIFIER_IMPLICIT_DECL (name)
4045               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4046             TREE_USED (x) = 1;
4047
4048           /* Don't forget if its address was taken in that way.  */
4049           if (IDENTIFIER_IMPLICIT_DECL (name)
4050               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4051             TREE_ADDRESSABLE (x) = 1;
4052
4053           /* Warn about mismatches against previous implicit decl.  */
4054           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4055               /* If this real decl matches the implicit, don't complain.  */
4056               && ! (TREE_CODE (x) == FUNCTION_DECL
4057                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4058             cp_warning
4059               ("`%D' was previously implicitly declared to return `int'", x);
4060
4061           /* If new decl is `static' and an `extern' was seen previously,
4062              warn about it.  */
4063           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4064             warn_extern_redeclared_static (x, t);
4065         }
4066       else
4067         {
4068           /* Here to install a non-global value.  */
4069           tree oldlocal = IDENTIFIER_VALUE (name);
4070           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4071
4072           if (need_new_binding)
4073             {
4074               push_local_binding (name, x, 0);
4075               /* Because push_local_binding will hook X on to the
4076                  current_binding_level's name list, we don't want to
4077                  do that again below.  */
4078               need_new_binding = 0;
4079             }
4080
4081           /* If this is a TYPE_DECL, push it into the type value slot.  */
4082           if (TREE_CODE (x) == TYPE_DECL)
4083             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4084                                                   current_binding_level);
4085
4086           /* Clear out any TYPE_DECL shadowed by a namespace so that
4087              we won't think this is a type.  The C struct hack doesn't
4088              go through namespaces.  */
4089           if (TREE_CODE (x) == NAMESPACE_DECL)
4090             set_identifier_type_value_with_scope (name, NULL_TREE,
4091                                                   current_binding_level);
4092
4093           if (oldlocal)
4094             {
4095               tree d = oldlocal;
4096
4097               while (oldlocal
4098                      && TREE_CODE (oldlocal) == VAR_DECL
4099                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4100                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4101
4102               if (oldlocal == NULL_TREE)
4103                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4104             }
4105
4106           /* If this is an extern function declaration, see if we
4107              have a global definition or declaration for the function.  */
4108           if (oldlocal == NULL_TREE
4109               && DECL_EXTERNAL (x)
4110               && oldglobal != NULL_TREE
4111               && TREE_CODE (x) == FUNCTION_DECL
4112               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4113             {
4114               /* We have one.  Their types must agree.  */
4115               if (decls_match (x, oldglobal))
4116                 /* OK */;
4117               else
4118                 {
4119                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4120                   cp_warning_at ("global declaration `%#D'", oldglobal);
4121                 }
4122             }
4123           /* If we have a local external declaration,
4124              and no file-scope declaration has yet been seen,
4125              then if we later have a file-scope decl it must not be static.  */
4126           if (oldlocal == NULL_TREE
4127               && oldglobal == NULL_TREE
4128               && DECL_EXTERNAL (x)
4129               && TREE_PUBLIC (x))
4130             TREE_PUBLIC (name) = 1;
4131
4132           /* Warn if shadowing an argument at the top level of the body.  */
4133           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4134               /* Inline decls shadow nothing.  */
4135               && !DECL_FROM_INLINE (x)
4136               && TREE_CODE (oldlocal) == PARM_DECL
4137               /* Don't complain if it's from an enclosing function.  */
4138               && DECL_CONTEXT (oldlocal) == current_function_decl
4139               && TREE_CODE (x) != PARM_DECL)
4140             {
4141               /* Go to where the parms should be and see if we
4142                  find them there.  */
4143               struct binding_level *b = current_binding_level->level_chain;
4144
4145               if (cleanup_label)
4146                 b = b->level_chain;
4147
4148               /* ARM $8.3 */
4149               if (b->parm_flag == 1)
4150                 cp_error ("declaration of `%#D' shadows a parameter", name);
4151             }
4152
4153           /* Maybe warn if shadowing something else.  */
4154           if (warn_shadow && !DECL_EXTERNAL (x)
4155               /* Inline decls shadow nothing.  */
4156               && !DECL_FROM_INLINE (x)
4157               /* No shadow warnings for internally generated vars.  */
4158               && ! DECL_ARTIFICIAL (x)
4159               /* No shadow warnings for vars made for inlining.  */
4160               && ! DECL_FROM_INLINE (x))
4161             {
4162               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4163                 warning ("declaration of `%s' shadows a parameter",
4164                         IDENTIFIER_POINTER (name));
4165               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4166                        && current_class_ptr
4167                        && !TREE_STATIC (name))
4168                 warning ("declaration of `%s' shadows a member of `this'",
4169                         IDENTIFIER_POINTER (name));
4170               else if (oldlocal != NULL_TREE)
4171                 warning ("declaration of `%s' shadows previous local",
4172                         IDENTIFIER_POINTER (name));
4173               else if (oldglobal != NULL_TREE)
4174                 /* XXX shadow warnings in outer-more namespaces */
4175                 warning ("declaration of `%s' shadows global declaration",
4176                         IDENTIFIER_POINTER (name));
4177             }
4178         }
4179
4180       if (TREE_CODE (x) == FUNCTION_DECL)
4181         check_default_args (x);
4182
4183       /* Keep count of variables in this level with incomplete type.  */
4184       if (TREE_CODE (x) == VAR_DECL
4185           && TREE_TYPE (x) != error_mark_node
4186           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4187                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4188               /* RTTI TD entries are created while defining the type_info.  */
4189               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4190                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4191         {
4192           if (namespace_bindings_p ())
4193             namespace_scope_incomplete
4194               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4195           else
4196             current_binding_level->incomplete
4197               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4198         }
4199     }
4200
4201   if (need_new_binding)
4202     add_decl_to_level (x,
4203                        DECL_NAMESPACE_SCOPE_P (x)
4204                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4205                        : current_binding_level);
4206
4207   return x;
4208 }
4209
4210 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4211    caller to set DECL_CONTEXT properly.  */
4212
4213 static tree
4214 pushdecl_with_scope (x, level)
4215      tree x;
4216      struct binding_level *level;
4217 {
4218   register struct binding_level *b;
4219   tree function_decl = current_function_decl;
4220
4221   current_function_decl = NULL_TREE;
4222   if (level->parm_flag == 2)
4223     {
4224       b = class_binding_level;
4225       class_binding_level = level;
4226       pushdecl_class_level (x);
4227       class_binding_level = b;
4228     }
4229   else
4230     {
4231       b = current_binding_level;
4232       current_binding_level = level;
4233       x = pushdecl (x);
4234       current_binding_level = b;
4235     }
4236   current_function_decl = function_decl;
4237   return x;
4238 }
4239
4240 /* Like pushdecl, only it places X in the current namespace,
4241    if appropriate.  */
4242
4243 tree
4244 pushdecl_namespace_level (x)
4245      tree x;
4246 {
4247   register struct binding_level *b = current_binding_level;
4248   register tree t;
4249
4250   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4251
4252   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4253      what we want.  */
4254   if (TREE_CODE (x) == TYPE_DECL)
4255     {
4256       tree name = DECL_NAME (x);
4257       tree newval;
4258       tree *ptr = (tree *)0;
4259       for (; b != global_binding_level; b = b->level_chain)
4260         {
4261           tree shadowed = b->type_shadowed;
4262           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4263             if (TREE_PURPOSE (shadowed) == name)
4264               {
4265                 ptr = &TREE_VALUE (shadowed);
4266                 /* Can't break out of the loop here because sometimes
4267                    a binding level will have duplicate bindings for
4268                    PT names.  It's gross, but I haven't time to fix it.  */
4269               }
4270         }
4271       newval = TREE_TYPE (x);
4272       if (ptr == (tree *)0)
4273         {
4274           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4275              up here if this is changed to an assertion.  --KR  */
4276           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4277         }
4278       else
4279         {
4280           *ptr = newval;
4281         }
4282     }
4283   return t;
4284 }
4285
4286 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4287    if appropriate.  */
4288
4289 tree
4290 pushdecl_top_level (x)
4291      tree x;
4292 {
4293   push_to_top_level ();
4294   x = pushdecl_namespace_level (x);
4295   pop_from_top_level ();
4296   return x;
4297 }
4298
4299 /* Make the declaration of X appear in CLASS scope.  */
4300
4301 void
4302 pushdecl_class_level (x)
4303      tree x;
4304 {
4305   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4306      scope looks for the pre-mangled name.  */
4307   register tree name;
4308
4309   if (TREE_CODE (x) == OVERLOAD)
4310     x = OVL_CURRENT (x);
4311   name = DECL_NAME (x);
4312
4313   if (name)
4314     {
4315       push_class_level_binding (name, x);
4316       if (TREE_CODE (x) == TYPE_DECL)
4317         set_identifier_type_value (name, TREE_TYPE (x));
4318     }
4319   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4320     {
4321       tree f;
4322
4323       for (f = TYPE_FIELDS (TREE_TYPE (x));
4324            f;
4325            f = TREE_CHAIN (f))
4326         pushdecl_class_level (f);
4327     }
4328 }
4329
4330 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4331    DECL, or a modified version thereof.  */
4332
4333 tree
4334 maybe_push_decl (decl)
4335      tree decl;
4336 {
4337   tree type = TREE_TYPE (decl);
4338
4339   /* Add this decl to the current binding level, but not if it comes
4340      from another scope, e.g. a static member variable.  TEM may equal
4341      DECL or it may be a previous decl of the same name.  */
4342   if (decl == error_mark_node
4343       || (TREE_CODE (decl) != PARM_DECL
4344           && DECL_CONTEXT (decl) != NULL_TREE
4345           /* Definitions of namespace members outside their namespace are
4346              possible. */
4347           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4348       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4349       || TREE_CODE (type) == UNKNOWN_TYPE
4350       /* The declaration of a template specialization does not affect
4351          the functions available for overload resolution, so we do not
4352          call pushdecl.  */
4353       || (TREE_CODE (decl) == FUNCTION_DECL
4354           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4355     return decl;
4356   else
4357     return pushdecl (decl);
4358 }
4359
4360 /* Make the declaration(s) of X appear in CLASS scope
4361    under the name NAME.  */
4362
4363 void
4364 push_class_level_binding (name, x)
4365      tree name;
4366      tree x;
4367 {
4368   tree binding;
4369   /* The class_binding_level will be NULL if x is a template
4370      parameter name in a member template.  */
4371   if (!class_binding_level)
4372     return;
4373
4374   /* Make sure that this new member does not have the same name
4375      as a template parameter.  */
4376   if (TYPE_BEING_DEFINED (current_class_type))
4377     check_template_shadow (x);
4378
4379   /* If this declaration shadows a declaration from an enclosing
4380      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4381      we leave this class.  Record the shadowed declaration here.  */
4382   binding = IDENTIFIER_BINDING (name);
4383   if (binding
4384       && ((TREE_CODE (x) == OVERLOAD
4385            && BINDING_VALUE (binding)
4386            && is_overloaded_fn (BINDING_VALUE (binding)))
4387           || INHERITED_VALUE_BINDING_P (binding)))
4388     {
4389       tree shadow;
4390       tree old_decl;
4391
4392       /* If the old binding was from a base class, and was for a tag
4393          name, slide it over to make room for the new binding.  The
4394          old binding is still visible if explicitly qualified with a
4395          class-key.  */
4396       if (INHERITED_VALUE_BINDING_P (binding)
4397           && BINDING_VALUE (binding)
4398           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4399           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4400           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4401         {
4402           old_decl = BINDING_TYPE (binding);
4403           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4404           BINDING_VALUE (binding) = NULL_TREE;
4405           INHERITED_VALUE_BINDING_P (binding) = 0;
4406         }
4407       else
4408         old_decl = BINDING_VALUE (binding);
4409
4410       /* Find the previous binding of name on the class-shadowed
4411          list, and update it.  */
4412       for (shadow = class_binding_level->class_shadowed;
4413            shadow;
4414            shadow = TREE_CHAIN (shadow))
4415         if (TREE_PURPOSE (shadow) == name
4416             && TREE_TYPE (shadow) == old_decl)
4417           {
4418             BINDING_VALUE (binding) = x;
4419             INHERITED_VALUE_BINDING_P (binding) = 0;
4420             TREE_TYPE (shadow) = x;
4421             IDENTIFIER_CLASS_VALUE (name) = x;
4422             return;
4423           }
4424     }
4425
4426   /* If we didn't replace an existing binding, put the binding on the
4427      stack of bindings for the identifier, and update the shadowed list.  */
4428   if (push_class_binding (name, x))
4429     {
4430       class_binding_level->class_shadowed
4431         = tree_cons (name, NULL,
4432                      class_binding_level->class_shadowed);
4433       /* Record the value we are binding NAME to so that we can know
4434          what to pop later.  */
4435       TREE_TYPE (class_binding_level->class_shadowed) = x;
4436     }
4437 }
4438
4439 /* Insert another USING_DECL into the current binding level, returning
4440    this declaration. If this is a redeclaration, do nothing, and
4441    return NULL_TREE if this not in namespace scope (in namespace
4442    scope, a using decl might extend any previous bindings).  */
4443
4444 tree
4445 push_using_decl (scope, name)
4446      tree scope;
4447      tree name;
4448 {
4449   tree decl;
4450
4451   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4452   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4453   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4454     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4455       break;
4456   if (decl)
4457     return namespace_bindings_p () ? decl : NULL_TREE;
4458   decl = build_lang_decl (USING_DECL, name, void_type_node);
4459   DECL_INITIAL (decl) = scope;
4460   TREE_CHAIN (decl) = current_binding_level->usings;
4461   current_binding_level->usings = decl;
4462   return decl;
4463 }
4464
4465 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4466    changed (i.e. there was already a directive), or the fresh
4467    TREE_LIST otherwise.  */
4468
4469 tree
4470 push_using_directive (used)
4471      tree used;
4472 {
4473   tree ud = current_binding_level->using_directives;
4474   tree iter, ancestor;
4475
4476   /* Check if we already have this. */
4477   if (purpose_member (used, ud) != NULL_TREE)
4478     return NULL_TREE;
4479
4480   /* Recursively add all namespaces used. */
4481   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4482     push_using_directive (TREE_PURPOSE (iter));
4483
4484   ancestor = namespace_ancestor (current_decl_namespace (), used);
4485   ud = current_binding_level->using_directives;
4486   ud = tree_cons (used, ancestor, ud);
4487   current_binding_level->using_directives = ud;
4488   return ud;
4489 }
4490
4491 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4492    other definitions already in place.  We get around this by making
4493    the value of the identifier point to a list of all the things that
4494    want to be referenced by that name.  It is then up to the users of
4495    that name to decide what to do with that list.
4496
4497    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4498    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4499
4500    FLAGS is a bitwise-or of the following values:
4501      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4502                  namespace scope.
4503      PUSH_USING: DECL is being pushed as the result of a using
4504                  declaration.
4505
4506    The value returned may be a previous declaration if we guessed wrong
4507    about what language DECL should belong to (C or C++).  Otherwise,
4508    it's always DECL (and never something that's not a _DECL).  */
4509
4510 tree
4511 push_overloaded_decl (decl, flags)
4512      tree decl;
4513      int flags;
4514 {
4515   tree name = DECL_NAME (decl);
4516   tree old;
4517   tree new_binding;
4518   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4519
4520   if (doing_global)
4521     old = namespace_binding (name, DECL_CONTEXT (decl));
4522   else
4523     old = lookup_name_current_level (name);
4524
4525   if (old)
4526     {
4527       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4528         {
4529           tree t = TREE_TYPE (old);
4530           if (IS_AGGR_TYPE (t) && warn_shadow
4531               && (! DECL_IN_SYSTEM_HEADER (decl)
4532                   || ! DECL_IN_SYSTEM_HEADER (old)))
4533             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4534           old = NULL_TREE;
4535         }
4536       else if (is_overloaded_fn (old))
4537         {
4538           tree tmp;
4539
4540           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4541             {
4542               tree fn = OVL_CURRENT (tmp);
4543
4544               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4545                   && !(flags & PUSH_USING)
4546                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4547                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4548                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4549                           decl, fn);
4550
4551               if (duplicate_decls (decl, fn))
4552                 return fn;
4553             }
4554         }
4555       else if (old == error_mark_node)
4556         /* Ignore the undefined symbol marker.  */
4557         old = NULL_TREE;
4558       else
4559         {
4560           cp_error_at ("previous non-function declaration `%#D'", old);
4561           cp_error ("conflicts with function declaration `%#D'", decl);
4562           return decl;
4563         }
4564     }
4565
4566   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4567     {
4568       if (old && TREE_CODE (old) != OVERLOAD)
4569         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4570       else
4571         new_binding = ovl_cons (decl, old);
4572       if (flags & PUSH_USING)
4573         OVL_USED (new_binding) = 1;
4574     }
4575   else
4576     /* NAME is not ambiguous.  */
4577     new_binding = decl;
4578
4579   if (doing_global)
4580     set_namespace_binding (name, current_namespace, new_binding);
4581   else
4582     {
4583       /* We only create an OVERLOAD if there was a previous binding at
4584          this level, or if decl is a template. In the former case, we
4585          need to remove the old binding and replace it with the new
4586          binding.  We must also run through the NAMES on the binding
4587          level where the name was bound to update the chain.  */
4588
4589       if (TREE_CODE (new_binding) == OVERLOAD && old)
4590         {
4591           tree *d;
4592
4593           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4594                *d;
4595                d = &TREE_CHAIN (*d))
4596             if (*d == old
4597                 || (TREE_CODE (*d) == TREE_LIST
4598                     && TREE_VALUE (*d) == old))
4599               {
4600                 if (TREE_CODE (*d) == TREE_LIST)
4601                   /* Just replace the old binding with the new.  */
4602                   TREE_VALUE (*d) = new_binding;
4603                 else
4604                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4605                   *d = tree_cons (NULL_TREE, new_binding,
4606                                   TREE_CHAIN (*d));
4607
4608                 /* And update the CPLUS_BINDING node.  */
4609                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4610                   = new_binding;
4611                 return decl;
4612               }
4613
4614           /* We should always find a previous binding in this case.  */
4615           my_friendly_abort (0);
4616         }
4617
4618       /* Install the new binding.  */
4619       push_local_binding (name, new_binding, flags);
4620     }
4621
4622   return decl;
4623 }
4624 \f
4625 /* Generate an implicit declaration for identifier FUNCTIONID
4626    as a function of type int ().  Print a warning if appropriate.  */
4627
4628 tree
4629 implicitly_declare (functionid)
4630      tree functionid;
4631 {
4632   register tree decl;
4633
4634   /* We used to reuse an old implicit decl here,
4635      but this loses with inline functions because it can clobber
4636      the saved decl chains.  */
4637   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4638
4639   DECL_EXTERNAL (decl) = 1;
4640   TREE_PUBLIC (decl) = 1;
4641
4642   /* ISO standard says implicit declarations are in the innermost block.
4643      So we record the decl in the standard fashion.  */
4644   pushdecl (decl);
4645   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4646
4647   if (warn_implicit
4648       /* Only one warning per identifier.  */
4649       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4650     {
4651       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4652     }
4653
4654   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4655
4656   return decl;
4657 }
4658
4659 /* Return zero if the declaration NEWDECL is valid
4660    when the declaration OLDDECL (assumed to be for the same name)
4661    has already been seen.
4662    Otherwise return an error message format string with a %s
4663    where the identifier should go.  */
4664
4665 static const char *
4666 redeclaration_error_message (newdecl, olddecl)
4667      tree newdecl, olddecl;
4668 {
4669   if (TREE_CODE (newdecl) == TYPE_DECL)
4670     {
4671       /* Because C++ can put things into name space for free,
4672          constructs like "typedef struct foo { ... } foo"
4673          would look like an erroneous redeclaration.  */
4674       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4675         return 0;
4676       else
4677         return "redefinition of `%#D'";
4678     }
4679   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4680     {
4681       /* If this is a pure function, its olddecl will actually be
4682          the original initialization to `0' (which we force to call
4683          abort()).  Don't complain about redefinition in this case.  */
4684       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4685         return 0;
4686
4687       /* If both functions come from different namespaces, this is not
4688          a redeclaration - this is a conflict with a used function. */
4689       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4690           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4691         return "`%D' conflicts with used function";
4692
4693       /* We'll complain about linkage mismatches in
4694          warn_extern_redeclared_static.  */
4695
4696       /* Defining the same name twice is no good.  */
4697       if (DECL_INITIAL (olddecl) != NULL_TREE
4698           && DECL_INITIAL (newdecl) != NULL_TREE)
4699         {
4700           if (DECL_NAME (olddecl) == NULL_TREE)
4701             return "`%#D' not declared in class";
4702           else
4703             return "redefinition of `%#D'";
4704         }
4705       return 0;
4706     }
4707   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4708     {
4709       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4710            && (DECL_TEMPLATE_RESULT (newdecl)
4711                != DECL_TEMPLATE_RESULT (olddecl))
4712            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4713            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4714           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4715               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4716               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4717         return "redefinition of `%#D'";
4718       return 0;
4719     }
4720   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4721     {
4722       /* Objects declared at top level:  */
4723       /* If at least one is a reference, it's ok.  */
4724       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4725         return 0;
4726       /* Reject two definitions.  */
4727       return "redefinition of `%#D'";
4728     }
4729   else
4730     {
4731       /* Objects declared with block scope:  */
4732       /* Reject two definitions, and reject a definition
4733          together with an external reference.  */
4734       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4735         return "redeclaration of `%#D'";
4736       return 0;
4737     }
4738 }
4739 \f
4740 /* Create a new label, named ID.  */
4741
4742 static tree
4743 make_label_decl (id, local_p)
4744      tree id;
4745      int local_p;
4746 {
4747   tree decl;
4748
4749   decl = build_decl (LABEL_DECL, id, void_type_node);
4750   if (expanding_p)
4751     /* Make sure every label has an rtx.  */
4752     label_rtx (decl);
4753
4754   DECL_CONTEXT (decl) = current_function_decl;
4755   DECL_MODE (decl) = VOIDmode;
4756   C_DECLARED_LABEL_FLAG (decl) = local_p;
4757
4758   /* Say where one reference is to the label, for the sake of the
4759      error if it is not defined.  */
4760   DECL_SOURCE_LINE (decl) = lineno;
4761   DECL_SOURCE_FILE (decl) = input_filename;
4762
4763   /* Record the fact that this identifier is bound to this label.  */
4764   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4765
4766   return decl;
4767 }
4768
4769 /* Record this label on the list of used labels so that we can check
4770    at the end of the function to see whether or not the label was
4771    actually defined, and so we can check when the label is defined whether
4772    this use is valid.  */
4773
4774 static void
4775 use_label (decl)
4776      tree decl;
4777 {
4778   if (named_label_uses == NULL
4779       || named_label_uses->names_in_scope != current_binding_level->names
4780       || named_label_uses->label_decl != decl)
4781     {
4782       struct named_label_use_list *new_ent;
4783       new_ent = ((struct named_label_use_list *)
4784                  ggc_alloc (sizeof (struct named_label_use_list)));
4785       new_ent->label_decl = decl;
4786       new_ent->names_in_scope = current_binding_level->names;
4787       new_ent->binding_level = current_binding_level;
4788       new_ent->lineno_o_goto = lineno;
4789       new_ent->filename_o_goto = input_filename;
4790       new_ent->next = named_label_uses;
4791       named_label_uses = new_ent;
4792     }
4793 }
4794
4795 /* Look for a label named ID in the current function.  If one cannot
4796    be found, create one.  (We keep track of used, but undefined,
4797    labels, and complain about them at the end of a function.)  */
4798
4799 tree
4800 lookup_label (id)
4801      tree id;
4802 {
4803   tree decl;
4804   struct named_label_list *ent;
4805
4806   /* You can't use labels at global scope.  */
4807   if (current_function_decl == NULL_TREE)
4808     {
4809       error ("label `%s' referenced outside of any function",
4810              IDENTIFIER_POINTER (id));
4811       return NULL_TREE;
4812     }
4813
4814   /* See if we've already got this label.  */
4815   decl = IDENTIFIER_LABEL_VALUE (id);
4816   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4817     return decl;
4818
4819   /* Record this label on the list of labels used in this function.
4820      We do this before calling make_label_decl so that we get the
4821      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4822   ent = ((struct named_label_list *)
4823          ggc_alloc_cleared (sizeof (struct named_label_list)));
4824   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4825   ent->next = named_labels;
4826   named_labels = ent;
4827
4828   /* We need a new label.  */
4829   decl = make_label_decl (id, /*local_p=*/0);
4830
4831   /* Now fill in the information we didn't have before.  */
4832   ent->label_decl = decl;
4833
4834   return decl;
4835 }
4836
4837 /* Declare a local label named ID.  */
4838
4839 tree
4840 declare_local_label (id)
4841      tree id;
4842 {
4843   tree decl;
4844
4845   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4846      this scope we can restore the old value of
4847      IDENTIFIER_TYPE_VALUE.  */
4848   current_binding_level->shadowed_labels
4849     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4850                  current_binding_level->shadowed_labels);
4851   /* Look for the label.  */
4852   decl = make_label_decl (id, /*local_p=*/1);
4853   /* Now fill in the information we didn't have before.  */
4854   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4855
4856   return decl;
4857 }
4858
4859 /* Returns nonzero if it is ill-formed to jump past the declaration of
4860    DECL.  Returns 2 if it's also a real problem.  */
4861
4862 static int
4863 decl_jump_unsafe (decl)
4864      tree decl;
4865 {
4866   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4867     return 0;
4868
4869   if (DECL_INITIAL (decl) == NULL_TREE
4870       && pod_type_p (TREE_TYPE (decl)))
4871     return 0;
4872
4873   /* This is really only important if we're crossing an initialization.
4874      The POD stuff is just pedantry; why should it matter if the class
4875      contains a field of pointer to member type?  */
4876   if (DECL_INITIAL (decl)
4877       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4878     return 2;
4879   return 1;
4880 }
4881
4882 /* Check that a single previously seen jump to a newly defined label
4883    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4884    the jump context; NAMES are the names in scope in LEVEL at the jump
4885    context; FILE and LINE are the source position of the jump or 0.  */
4886
4887 static void
4888 check_previous_goto_1 (decl, level, names, file, line)
4889      tree decl;
4890      struct binding_level *level;
4891      tree names;
4892      const char *file;
4893      int line;
4894 {
4895   int identified = 0;
4896   int saw_eh = 0;
4897   struct binding_level *b = current_binding_level;
4898   for (; b; b = b->level_chain)
4899     {
4900       tree new_decls = b->names;
4901       tree old_decls = (b == level ? names : NULL_TREE);
4902       for (; new_decls != old_decls;
4903            new_decls = TREE_CHAIN (new_decls))
4904         {
4905           int problem = decl_jump_unsafe (new_decls);
4906           if (! problem)
4907             continue;
4908
4909           if (! identified)
4910             {
4911               if (decl)
4912                 cp_pedwarn ("jump to label `%D'", decl);
4913               else
4914                 pedwarn ("jump to case label");
4915
4916               if (file)
4917                 pedwarn_with_file_and_line (file, line, "  from here");
4918               identified = 1;
4919             }
4920
4921           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4922             /* Can't skip init of __exception_info.  */
4923             cp_error_at ("  enters catch block", new_decls);
4924           else if (problem > 1)
4925             cp_error_at ("  crosses initialization of `%#D'",
4926                          new_decls);
4927           else
4928             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4929                            new_decls);
4930         }
4931
4932       if (b == level)
4933         break;
4934       if (b->eh_region && ! saw_eh)
4935         {
4936           if (! identified)
4937             {
4938               if (decl)
4939                 cp_pedwarn ("jump to label `%D'", decl);
4940               else
4941                 pedwarn ("jump to case label");
4942
4943               if (file)
4944                 pedwarn_with_file_and_line (file, line, "  from here");
4945               identified = 1;
4946             }
4947           error ("  enters try block");
4948           saw_eh = 1;
4949         }
4950     }
4951 }
4952
4953 static void
4954 check_previous_goto (use)
4955      struct named_label_use_list *use;
4956 {
4957   check_previous_goto_1 (use->label_decl, use->binding_level,
4958                          use->names_in_scope, use->filename_o_goto,
4959                          use->lineno_o_goto);
4960 }
4961
4962 static void
4963 check_switch_goto (level)
4964      struct binding_level *level;
4965 {
4966   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4967 }
4968
4969 /* Check that any previously seen jumps to a newly defined label DECL
4970    are OK.  Called by define_label.  */
4971
4972 static void
4973 check_previous_gotos (decl)
4974      tree decl;
4975 {
4976   struct named_label_use_list **usep;
4977
4978   if (! TREE_USED (decl))
4979     return;
4980
4981   for (usep = &named_label_uses; *usep; )
4982     {
4983       struct named_label_use_list *use = *usep;
4984       if (use->label_decl == decl)
4985         {
4986           check_previous_goto (use);
4987           *usep = use->next;
4988         }
4989       else
4990         usep = &(use->next);
4991     }
4992 }
4993
4994 /* Check that a new jump to a label DECL is OK.  Called by
4995    finish_goto_stmt.  */
4996
4997 void
4998 check_goto (decl)
4999      tree decl;
5000 {
5001   int identified = 0;
5002   tree bad;
5003   struct named_label_list *lab;
5004
5005   /* We can't know where a computed goto is jumping.  So we assume
5006      that it's OK.  */
5007   if (! DECL_P (decl))
5008     return;
5009
5010   /* If the label hasn't been defined yet, defer checking.  */
5011   if (! DECL_INITIAL (decl))
5012     {
5013       use_label (decl);
5014       return;
5015     }
5016
5017   for (lab = named_labels; lab; lab = lab->next)
5018     if (decl == lab->label_decl)
5019       break;
5020
5021   /* If the label is not on named_labels it's a gcc local label, so
5022      it must be in an outer scope, so jumping to it is always OK.  */
5023   if (lab == 0)
5024     return;
5025
5026   if ((lab->eh_region || lab->bad_decls) && !identified)
5027     {
5028       cp_pedwarn_at ("jump to label `%D'", decl);
5029       pedwarn ("  from here");
5030       identified = 1;
5031     }
5032
5033   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5034     {
5035       tree b = TREE_VALUE (bad);
5036       int u = decl_jump_unsafe (b);
5037
5038       if (u > 1 && DECL_ARTIFICIAL (b))
5039         /* Can't skip init of __exception_info.  */
5040         cp_error_at ("  enters catch block", b);
5041       else if (u > 1)
5042         cp_error_at ("  skips initialization of `%#D'", b);
5043       else
5044         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5045     }
5046
5047   if (lab->eh_region)
5048     error ("  enters try block");
5049 }
5050
5051 /* Define a label, specifying the location in the source file.
5052    Return the LABEL_DECL node for the label, if the definition is valid.
5053    Otherwise return 0.  */
5054
5055 tree
5056 define_label (filename, line, name)
5057      const char *filename;
5058      int line;
5059      tree name;
5060 {
5061   tree decl = lookup_label (name);
5062   struct named_label_list *ent;
5063   register struct binding_level *p;
5064
5065   for (ent = named_labels; ent; ent = ent->next)
5066     if (ent->label_decl == decl)
5067       break;
5068
5069   /* After labels, make any new cleanups in the function go into their
5070      own new (temporary) binding contour.  */
5071   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5072     p->more_cleanups_ok = 0;
5073
5074   if (name == get_identifier ("wchar_t"))
5075     cp_pedwarn ("label named wchar_t");
5076
5077   if (DECL_INITIAL (decl) != NULL_TREE)
5078     {
5079       cp_error ("duplicate label `%D'", decl);
5080       return 0;
5081     }
5082   else
5083     {
5084       /* Mark label as having been defined.  */
5085       DECL_INITIAL (decl) = error_mark_node;
5086       /* Say where in the source.  */
5087       DECL_SOURCE_FILE (decl) = filename;
5088       DECL_SOURCE_LINE (decl) = line;
5089       if (ent)
5090         {
5091           ent->names_in_scope = current_binding_level->names;
5092           ent->binding_level = current_binding_level;
5093         }
5094       check_previous_gotos (decl);
5095       current_function_return_value = NULL_TREE;
5096       return decl;
5097     }
5098 }
5099
5100 struct cp_switch
5101 {
5102   struct binding_level *level;
5103   struct cp_switch *next;
5104   /* The SWITCH_STMT being built.  */
5105   tree switch_stmt;
5106   /* A splay-tree mapping the low element of a case range to the high
5107      element, or NULL_TREE if there is no high element.  Used to
5108      determine whether or not a new case label duplicates an old case
5109      label.  We need a tree, rather than simply a hash table, because
5110      of the GNU case range extension.  */
5111   splay_tree cases;
5112 };
5113
5114 /* A stack of the currently active switch statements.  The innermost
5115    switch statement is on the top of the stack.  There is no need to
5116    mark the stack for garbage collection because it is only active
5117    during the processing of the body of a function, and we never
5118    collect at that point.  */
5119
5120 static struct cp_switch *switch_stack;
5121
5122 /* Called right after a switch-statement condition is parsed.
5123    SWITCH_STMT is the switch statement being parsed.  */
5124
5125 void
5126 push_switch (switch_stmt)
5127      tree switch_stmt;
5128 {
5129   struct cp_switch *p
5130     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5131   p->level = current_binding_level;
5132   p->next = switch_stack;
5133   p->switch_stmt = switch_stmt;
5134   p->cases = splay_tree_new (case_compare, NULL, NULL);
5135   switch_stack = p;
5136 }
5137
5138 void
5139 pop_switch ()
5140 {
5141   struct cp_switch *cs;
5142
5143   cs = switch_stack;
5144   splay_tree_delete (cs->cases);
5145   switch_stack = switch_stack->next;
5146   free (cs);
5147 }
5148
5149 /* Note that we've seen a definition of a case label, and complain if this
5150    is a bad place for one.  */
5151
5152 tree
5153 finish_case_label (low_value, high_value)
5154      tree low_value;
5155      tree high_value;
5156 {
5157   tree cond, r;
5158   register struct binding_level *p;
5159
5160   if (! switch_stack)
5161     {
5162       if (high_value)
5163         error ("case label not within a switch statement");
5164       else if (low_value)
5165         cp_error ("case label `%E' not within a switch statement",
5166                   low_value);
5167       else
5168         error ("`default' label not within a switch statement");
5169       return NULL_TREE;
5170     }
5171
5172   if (processing_template_decl)
5173     {
5174       tree label;
5175
5176       /* For templates, just add the case label; we'll do semantic
5177          analysis at instantiation-time.  */
5178       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5179       return add_stmt (build_case_label (low_value, high_value, label));
5180     }
5181
5182   /* Find the condition on which this switch statement depends.  */
5183   cond = SWITCH_COND (switch_stack->switch_stmt);
5184   if (cond && TREE_CODE (cond) == TREE_LIST)
5185     cond = TREE_VALUE (cond);
5186
5187   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5188   if (r == error_mark_node)
5189     r = NULL_TREE;
5190
5191   check_switch_goto (switch_stack->level);
5192
5193   /* After labels, make any new cleanups in the function go into their
5194      own new (temporary) binding contour.  */
5195   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5196     p->more_cleanups_ok = 0;
5197   current_function_return_value = NULL_TREE;
5198
5199   return r;
5200 }
5201 \f
5202 /* Return the list of declarations of the current level.
5203    Note that this list is in reverse order unless/until
5204    you nreverse it; and when you do nreverse it, you must
5205    store the result back using `storedecls' or you will lose.  */
5206
5207 tree
5208 getdecls ()
5209 {
5210   return current_binding_level->names;
5211 }
5212
5213 /* Return the list of type-tags (for structs, etc) of the current level.  */
5214
5215 tree
5216 gettags ()
5217 {
5218   return current_binding_level->tags;
5219 }
5220
5221 /* Store the list of declarations of the current level.
5222    This is done for the parameter declarations of a function being defined,
5223    after they are modified in the light of any missing parameters.  */
5224
5225 static void
5226 storedecls (decls)
5227      tree decls;
5228 {
5229   current_binding_level->names = decls;
5230 }
5231
5232 /* Similarly, store the list of tags of the current level.  */
5233
5234 void
5235 storetags (tags)
5236      tree tags;
5237 {
5238   current_binding_level->tags = tags;
5239 }
5240 \f
5241 /* Given NAME, an IDENTIFIER_NODE,
5242    return the structure (or union or enum) definition for that name.
5243    Searches binding levels from BINDING_LEVEL up to the global level.
5244    If THISLEVEL_ONLY is nonzero, searches only the specified context
5245    (but skips any tag-transparent contexts to find one that is
5246    meaningful for tags).
5247    FORM says which kind of type the caller wants;
5248    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5249    If the wrong kind of type is found, and it's not a template, an error is
5250    reported.  */
5251
5252 static tree
5253 lookup_tag (form, name, binding_level, thislevel_only)
5254      enum tree_code form;
5255      tree name;
5256      struct binding_level *binding_level;
5257      int thislevel_only;
5258 {
5259   register struct binding_level *level;
5260   /* Non-zero if, we should look past a template parameter level, even
5261      if THISLEVEL_ONLY.  */
5262   int allow_template_parms_p = 1;
5263
5264   for (level = binding_level; level; level = level->level_chain)
5265     {
5266       register tree tail;
5267       if (ANON_AGGRNAME_P (name))
5268         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5269           {
5270             /* There's no need for error checking here, because
5271                anon names are unique throughout the compilation.  */
5272             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5273               return TREE_VALUE (tail);
5274           }
5275       else if (level->namespace_p)
5276         /* Do namespace lookup. */
5277         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5278           {
5279             tree old = binding_for_name (name, tail);
5280
5281             /* If we just skipped past a template parameter level,
5282                even though THISLEVEL_ONLY, and we find a template
5283                class declaration, then we use the _TYPE node for the
5284                template.  See the example below.  */
5285             if (thislevel_only && !allow_template_parms_p
5286                 && old && BINDING_VALUE (old)
5287                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5288               old = TREE_TYPE (BINDING_VALUE (old));
5289             else
5290               old = BINDING_TYPE (old);
5291
5292             /* If it has an original type, it is a typedef, and we
5293                should not return it.  */
5294             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5295               old = NULL_TREE;
5296             if (old && TREE_CODE (old) != form
5297                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5298               {
5299                 cp_error ("`%#D' redeclared as %C", old, form);
5300                 return NULL_TREE;
5301               }
5302             if (old)
5303               return old;
5304             if (thislevel_only || tail == global_namespace)
5305               return NULL_TREE;
5306           }
5307       else
5308         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5309           {
5310             if (TREE_PURPOSE (tail) == name)
5311               {
5312                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5313                 /* Should tighten this up; it'll probably permit
5314                    UNION_TYPE and a struct template, for example.  */
5315                 if (code != form
5316                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5317                   {
5318                     /* Definition isn't the kind we were looking for.  */
5319                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5320                               form);
5321                     return NULL_TREE;
5322                   }
5323                 return TREE_VALUE (tail);
5324               }
5325           }
5326       if (thislevel_only && ! level->tag_transparent)
5327         {
5328           if (level->template_parms_p && allow_template_parms_p)
5329             {
5330               /* We must deal with cases like this:
5331
5332                    template <class T> struct S;
5333                    template <class T> struct S {};
5334
5335                  When looking up `S', for the second declaration, we
5336                  would like to find the first declaration.  But, we
5337                  are in the pseudo-global level created for the
5338                  template parameters, rather than the (surrounding)
5339                  namespace level.  Thus, we keep going one more level,
5340                  even though THISLEVEL_ONLY is non-zero.  */
5341               allow_template_parms_p = 0;
5342               continue;
5343             }
5344           else
5345             return NULL_TREE;
5346         }
5347     }
5348   return NULL_TREE;
5349 }
5350
5351 #if 0
5352 void
5353 set_current_level_tags_transparency (tags_transparent)
5354      int tags_transparent;
5355 {
5356   current_binding_level->tag_transparent = tags_transparent;
5357 }
5358 #endif
5359
5360 /* Given a type, find the tag that was defined for it and return the tag name.
5361    Otherwise return 0.  However, the value can never be 0
5362    in the cases in which this is used.
5363
5364    C++: If NAME is non-zero, this is the new name to install.  This is
5365    done when replacing anonymous tags with real tag names.  */
5366
5367 static tree
5368 lookup_tag_reverse (type, name)
5369      tree type;
5370      tree name;
5371 {
5372   register struct binding_level *level;
5373
5374   for (level = current_binding_level; level; level = level->level_chain)
5375     {
5376       register tree tail;
5377       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5378         {
5379           if (TREE_VALUE (tail) == type)
5380             {
5381               if (name)
5382                 TREE_PURPOSE (tail) = name;
5383               return TREE_PURPOSE (tail);
5384             }
5385         }
5386     }
5387   return NULL_TREE;
5388 }
5389 \f
5390 /* Look up NAME in the NAMESPACE.  */
5391
5392 tree
5393 lookup_namespace_name (namespace, name)
5394      tree namespace, name;
5395 {
5396   tree val;
5397   tree template_id = NULL_TREE;
5398
5399   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5400
5401   if (TREE_CODE (name) == NAMESPACE_DECL)
5402     /* This happens for A::B<int> when B is a namespace. */
5403     return name;
5404   else if (TREE_CODE (name) == TEMPLATE_DECL)
5405     {
5406       /* This happens for A::B where B is a template, and there are no
5407          template arguments.  */
5408       cp_error ("invalid use of `%D'", name);
5409       return error_mark_node;
5410     }
5411
5412   namespace = ORIGINAL_NAMESPACE (namespace);
5413
5414   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5415     {
5416       template_id = name;
5417       name = TREE_OPERAND (name, 0);
5418       if (TREE_CODE (name) == OVERLOAD)
5419         name = DECL_NAME (OVL_CURRENT (name));
5420       else if (DECL_P (name))
5421         name = DECL_NAME (name);
5422     }
5423
5424   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5425
5426   val = make_node (CPLUS_BINDING);
5427   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5428     return error_mark_node;
5429
5430   if (BINDING_VALUE (val))
5431     {
5432       val = BINDING_VALUE (val);
5433
5434       if (template_id)
5435         {
5436           if (DECL_CLASS_TEMPLATE_P (val))
5437             val = lookup_template_class (val,
5438                                          TREE_OPERAND (template_id, 1),
5439                                          /*in_decl=*/NULL_TREE,
5440                                          /*context=*/NULL_TREE,
5441                                          /*entering_scope=*/0,
5442                                          /*complain=*/1);
5443           else if (DECL_FUNCTION_TEMPLATE_P (val)
5444                    || TREE_CODE (val) == OVERLOAD)
5445             val = lookup_template_function (val,
5446                                             TREE_OPERAND (template_id, 1));
5447           else
5448             {
5449               cp_error ("`%D::%D' is not a template",
5450                         namespace, name);
5451               return error_mark_node;
5452             }
5453         }
5454
5455       /* If we have a single function from a using decl, pull it out.  */
5456       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5457         val = OVL_FUNCTION (val);
5458       return val;
5459     }
5460
5461   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5462   return error_mark_node;
5463 }
5464
5465 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5466
5467 static unsigned long
5468 typename_hash (k)
5469      hash_table_key k;
5470 {
5471   unsigned long hash;
5472   tree t;
5473
5474   t = (tree) k;
5475   hash = (((unsigned long) TYPE_CONTEXT (t))
5476           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5477
5478   return hash;
5479 }
5480
5481 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5482
5483 static boolean
5484 typename_compare (k1, k2)
5485      hash_table_key k1;
5486      hash_table_key k2;
5487 {
5488   tree t1;
5489   tree t2;
5490   tree d1;
5491   tree d2;
5492
5493   t1 = (tree) k1;
5494   t2 = (tree) k2;
5495   d1 = TYPE_NAME (t1);
5496   d2 = TYPE_NAME (t2);
5497
5498   return (DECL_NAME (d1) == DECL_NAME (d2)
5499           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5500           && ((TREE_TYPE (t1) != NULL_TREE)
5501               == (TREE_TYPE (t2) != NULL_TREE))
5502           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5503           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5504 }
5505
5506 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5507    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5508    is non-NULL, this type is being created by the implicit typename
5509    extension, and BASE_TYPE is a type named `t' in some base class of
5510    `T' which depends on template parameters.
5511
5512    Returns the new TYPENAME_TYPE.  */
5513
5514 tree
5515 build_typename_type (context, name, fullname, base_type)
5516      tree context;
5517      tree name;
5518      tree fullname;
5519      tree base_type;
5520 {
5521   tree t;
5522   tree d;
5523   struct hash_entry* e;
5524
5525   static struct hash_table ht;
5526
5527   if (!ht.table)
5528     {
5529       static struct hash_table *h = &ht;
5530       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5531                             &typename_compare))
5532         fatal ("virtual memory exhausted");
5533       ggc_add_tree_hash_table_root (&h, 1);
5534     }
5535
5536   /* Build the TYPENAME_TYPE.  */
5537   t = make_aggr_type (TYPENAME_TYPE);
5538   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5539   TYPENAME_TYPE_FULLNAME (t) = fullname;
5540   TREE_TYPE (t) = base_type;
5541
5542   /* Build the corresponding TYPE_DECL.  */
5543   d = build_decl (TYPE_DECL, name, t);
5544   TYPE_NAME (TREE_TYPE (d)) = d;
5545   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5546   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5547   DECL_ARTIFICIAL (d) = 1;
5548
5549   /* See if we already have this type.  */
5550   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5551   if (e)
5552     t = (tree) e->key;
5553   else
5554     /* Insert the type into the table.  */
5555     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5556
5557   return t;
5558 }
5559
5560 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5561    unless an error occurs, in which case error_mark_node is returned.
5562    If COMPLAIN zero, don't complain about any errors that occur.  */
5563
5564 tree
5565 make_typename_type (context, name, complain)
5566      tree context, name;
5567      int complain;
5568 {
5569   tree fullname;
5570
5571   if (TYPE_P (name))
5572     {
5573       if (!(TYPE_LANG_SPECIFIC (name)
5574             && (CLASSTYPE_IS_TEMPLATE (name)
5575                 || CLASSTYPE_USE_TEMPLATE (name))))
5576         name = TYPE_IDENTIFIER (name);
5577       else
5578         /* Create a TEMPLATE_ID_EXPR for the type.  */
5579         name = build_nt (TEMPLATE_ID_EXPR,
5580                          CLASSTYPE_TI_TEMPLATE (name),
5581                          CLASSTYPE_TI_ARGS (name));
5582     }
5583   else if (TREE_CODE (name) == TYPE_DECL)
5584     name = DECL_NAME (name);
5585
5586   fullname = name;
5587
5588   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5589     {
5590       name = TREE_OPERAND (name, 0);
5591       if (TREE_CODE (name) == TEMPLATE_DECL)
5592         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5593     }
5594   if (TREE_CODE (name) != IDENTIFIER_NODE)
5595     my_friendly_abort (2000);
5596
5597   if (TREE_CODE (context) == NAMESPACE_DECL)
5598     {
5599       /* We can get here from typename_sub0 in the explicit_template_type
5600          expansion.  Just fail.  */
5601       if (complain)
5602         cp_error ("no class template named `%#T' in `%#T'",
5603                   name, context);
5604       return error_mark_node;
5605     }
5606
5607   if (! uses_template_parms (context)
5608       || currently_open_class (context))
5609     {
5610       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5611         {
5612           tree tmpl = NULL_TREE;
5613           if (IS_AGGR_TYPE (context))
5614             tmpl = lookup_field (context, name, 0, 0);
5615           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5616             {
5617               if (complain)
5618                 cp_error ("no class template named `%#T' in `%#T'",
5619                           name, context);
5620               return error_mark_node;
5621             }
5622
5623           return lookup_template_class (tmpl,
5624                                         TREE_OPERAND (fullname, 1),
5625                                         NULL_TREE, context,
5626                                         /*entering_scope=*/0,
5627                                         /*complain=*/1);
5628         }
5629       else
5630         {
5631           tree t;
5632
5633           if (!IS_AGGR_TYPE (context))
5634             {
5635               if (complain)
5636                 cp_error ("no type named `%#T' in `%#T'", name, context);
5637               return error_mark_node;
5638             }
5639
5640           t = lookup_field (context, name, 0, 1);
5641           if (t)
5642             return TREE_TYPE (t);
5643         }
5644     }
5645
5646   /* If the CONTEXT is not a template type, then either the field is
5647      there now or its never going to be.  */
5648   if (!uses_template_parms (context))
5649     {
5650       if (complain)
5651         cp_error ("no type named `%#T' in `%#T'", name, context);
5652       return error_mark_node;
5653     }
5654
5655
5656   return build_typename_type (context, name, fullname,  NULL_TREE);
5657 }
5658
5659 /* Select the right _DECL from multiple choices. */
5660
5661 static tree
5662 select_decl (binding, flags)
5663      tree binding;
5664      int flags;
5665 {
5666   tree val;
5667   val = BINDING_VALUE (binding);
5668
5669   /* When we implicitly declare some builtin entity, we mark it
5670      DECL_ANTICIPATED, so that we know to ignore it until it is
5671      really declared.  */
5672   if (val && DECL_P (val)
5673       && DECL_LANG_SPECIFIC (val)
5674       && DECL_ANTICIPATED (val))
5675     return NULL_TREE;
5676
5677   if (LOOKUP_NAMESPACES_ONLY (flags))
5678     {
5679       /* We are not interested in types. */
5680       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5681         return val;
5682       return NULL_TREE;
5683     }
5684
5685   /* If we could have a type and
5686      we have nothing or we need a type and have none.  */
5687   if (BINDING_TYPE (binding)
5688       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5689                    && TREE_CODE (val) != TYPE_DECL)))
5690     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5691   /* Don't return non-types if we really prefer types. */
5692   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5693            && (TREE_CODE (val) != TEMPLATE_DECL
5694                || !DECL_CLASS_TEMPLATE_P (val)))
5695     val = NULL_TREE;
5696
5697   return val;
5698 }
5699
5700 /* Unscoped lookup of a global: iterate over current namespaces,
5701    considering using-directives.  If SPACESP is non-NULL, store a list
5702    of the namespaces we've considered in it.  */
5703
5704 tree
5705 unqualified_namespace_lookup (name, flags, spacesp)
5706      tree name;
5707      int flags;
5708      tree *spacesp;
5709 {
5710   tree b = make_node (CPLUS_BINDING);
5711   tree initial = current_decl_namespace();
5712   tree scope = initial;
5713   tree siter;
5714   struct binding_level *level;
5715   tree val = NULL_TREE;
5716
5717   if (spacesp)
5718     *spacesp = NULL_TREE;
5719
5720   for (; !val; scope = CP_DECL_CONTEXT (scope))
5721     {
5722       if (spacesp)
5723         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5724       val = binding_for_name (name, scope);
5725
5726       /* Initialize binding for this context. */
5727       BINDING_VALUE (b) = BINDING_VALUE (val);
5728       BINDING_TYPE (b) = BINDING_TYPE (val);
5729
5730       /* Add all _DECLs seen through local using-directives. */
5731       for (level = current_binding_level;
5732            !level->namespace_p;
5733            level = level->level_chain)
5734         if (!lookup_using_namespace (name, b, level->using_directives,
5735                                      scope, flags, spacesp))
5736           /* Give up because of error. */
5737           return error_mark_node;
5738
5739       /* Add all _DECLs seen through global using-directives. */
5740       /* XXX local and global using lists should work equally. */
5741       siter = initial;
5742       while (1)
5743         {
5744           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5745                                        scope, flags, spacesp))
5746             /* Give up because of error. */
5747             return error_mark_node;
5748           if (siter == scope) break;
5749           siter = CP_DECL_CONTEXT (siter);
5750         }
5751
5752       val = select_decl (b, flags);
5753       if (scope == global_namespace)
5754         break;
5755     }
5756   return val;
5757 }
5758
5759 /* Combine prefer_type and namespaces_only into flags.  */
5760
5761 static int
5762 lookup_flags (prefer_type, namespaces_only)
5763   int prefer_type, namespaces_only;
5764 {
5765   if (namespaces_only)
5766     return LOOKUP_PREFER_NAMESPACES;
5767   if (prefer_type > 1)
5768     return LOOKUP_PREFER_TYPES;
5769   if (prefer_type > 0)
5770     return LOOKUP_PREFER_BOTH;
5771   return 0;
5772 }
5773
5774 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5775    ignore it or not.  Subroutine of lookup_name_real.  */
5776
5777 static tree
5778 qualify_lookup (val, flags)
5779      tree val;
5780      int flags;
5781 {
5782   if (val == NULL_TREE)
5783     return val;
5784   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5785     return val;
5786   if ((flags & LOOKUP_PREFER_TYPES)
5787       && (TREE_CODE (val) == TYPE_DECL
5788           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5789               && DECL_CLASS_TEMPLATE_P (val))))
5790     return val;
5791   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5792     return NULL_TREE;
5793   return val;
5794 }
5795
5796 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5797    that.  */
5798
5799 static void
5800 warn_about_implicit_typename_lookup (typename, binding)
5801      tree typename;
5802      tree binding;
5803 {
5804   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5805   tree name = DECL_NAME (typename);
5806
5807   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5808          && CLASSTYPE_TEMPLATE_INFO (subtype)
5809          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5810       && ! (TREE_CODE (binding) == TYPE_DECL
5811             && same_type_p (TREE_TYPE (binding), subtype)))
5812     {
5813       cp_warning ("lookup of `%D' finds `%#D'",
5814                   name, binding);
5815       cp_warning ("  instead of `%D' from dependent base class",
5816                   typename);
5817       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5818                   constructor_name (current_class_type), name);
5819     }
5820 }
5821
5822 /* Look up NAME in the current binding level and its superiors in the
5823    namespace of variables, functions and typedefs.  Return a ..._DECL
5824    node of some kind representing its definition if there is only one
5825    such declaration, or return a TREE_LIST with all the overloaded
5826    definitions if there are many, or return 0 if it is undefined.
5827
5828    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5829    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5830    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5831    Otherwise we prefer non-TYPE_DECLs.
5832
5833    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5834    using IDENTIFIER_CLASS_VALUE.  */
5835
5836 static tree
5837 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5838      tree name;
5839      int prefer_type, nonclass, namespaces_only;
5840 {
5841   tree t;
5842   tree val = NULL_TREE;
5843   int yylex = 0;
5844   tree from_obj = NULL_TREE;
5845   int flags;
5846   int val_is_implicit_typename = 0;
5847
5848   /* Hack: copy flag set by parser, if set. */
5849   if (only_namespace_names)
5850     namespaces_only = 1;
5851
5852   if (prefer_type == -2)
5853     {
5854       extern int looking_for_typename;
5855       tree type = NULL_TREE;
5856
5857       yylex = 1;
5858       prefer_type = looking_for_typename;
5859
5860       flags = lookup_flags (prefer_type, namespaces_only);
5861       /* If the next thing is '<', class templates are types. */
5862       if (looking_for_template)
5863         flags |= LOOKUP_TEMPLATES_EXPECTED;
5864
5865       /* std:: becomes :: for now.  */
5866       if (got_scope && got_scope == fake_std_node)
5867         got_scope = void_type_node;
5868
5869       if (got_scope)
5870         type = got_scope;
5871       else if (got_object != error_mark_node)
5872         type = got_object;
5873
5874       if (type)
5875         {
5876           if (type == error_mark_node)
5877             return error_mark_node;
5878           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5879             type = TREE_TYPE (type);
5880
5881           if (TYPE_P (type))
5882             type = complete_type (type);
5883
5884           if (TREE_CODE (type) == VOID_TYPE)
5885             type = global_namespace;
5886           if (TREE_CODE (type) == NAMESPACE_DECL)
5887             {
5888               val = make_node (CPLUS_BINDING);
5889               flags |= LOOKUP_COMPLAIN;
5890               if (!qualified_lookup_using_namespace (name, type, val, flags))
5891                 return NULL_TREE;
5892               val = select_decl (val, flags);
5893             }
5894           else if (! IS_AGGR_TYPE (type)
5895                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5896                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5897                    || TREE_CODE (type) == TYPENAME_TYPE)
5898             /* Someone else will give an error about this if needed.  */
5899             val = NULL_TREE;
5900           else if (type == current_class_type)
5901             val = IDENTIFIER_CLASS_VALUE (name);
5902           else
5903             {
5904               val = lookup_member (type, name, 0, prefer_type);
5905               type_access_control (type, val);
5906
5907               /* Restore the containing TYPENAME_TYPE if we looked
5908                  through it before.  */
5909               if (got_scope && got_scope != type
5910                   && val && TREE_CODE (val) == TYPE_DECL
5911                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5912                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5913             }
5914         }
5915       else
5916         val = NULL_TREE;
5917
5918       if (got_scope)
5919         goto done;
5920       else if (got_object && val)
5921         {
5922           from_obj = val;
5923           val = NULL_TREE;
5924         }
5925     }
5926   else
5927     {
5928       flags = lookup_flags (prefer_type, namespaces_only);
5929       /* If we're not parsing, we need to complain. */
5930       flags |= LOOKUP_COMPLAIN;
5931     }
5932
5933   /* First, look in non-namespace scopes.  */
5934
5935   if (current_class_type == NULL_TREE)
5936     nonclass = 1;
5937
5938   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5939     {
5940       tree binding;
5941
5942       if (!LOCAL_BINDING_P (t) && nonclass)
5943         /* We're not looking for class-scoped bindings, so keep going.  */
5944         continue;
5945
5946       /* If this is the kind of thing we're looking for, we're done.  */
5947       if (qualify_lookup (BINDING_VALUE (t), flags))
5948         binding = BINDING_VALUE (t);
5949       else if ((flags & LOOKUP_PREFER_TYPES)
5950                && qualify_lookup (BINDING_TYPE (t), flags))
5951         binding = BINDING_TYPE (t);
5952       else
5953         binding = NULL_TREE;
5954
5955       /* Handle access control on types from enclosing or base classes.  */
5956       if (binding && ! yylex
5957           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5958         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5959
5960       if (binding
5961           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5962         {
5963           if (val_is_implicit_typename && !yylex)
5964             warn_about_implicit_typename_lookup (val, binding);
5965           val = binding;
5966           val_is_implicit_typename
5967             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5968           if (!val_is_implicit_typename)
5969             break;
5970         }
5971     }
5972
5973   /* Now lookup in namespace scopes.  */
5974   if (!val || val_is_implicit_typename)
5975     {
5976       t = unqualified_namespace_lookup (name, flags, 0);
5977       if (t)
5978         {
5979           if (val_is_implicit_typename && !yylex)
5980             warn_about_implicit_typename_lookup (val, t);
5981           val = t;
5982         }
5983     }
5984
5985  done:
5986   if (val)
5987     {
5988       /* This should only warn about types used in qualified-ids.  */
5989       if (from_obj && from_obj != val)
5990         {
5991           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5992               && TREE_CODE (val) == TYPE_DECL
5993               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
5994             cp_pedwarn ("\
5995 lookup of `%D' in the scope of `%#T' (`%#T') \
5996 does not match lookup in the current scope (`%#T')",
5997                         name, got_object, TREE_TYPE (from_obj),
5998                         TREE_TYPE (val));
5999
6000           /* We don't change val to from_obj if got_object depends on
6001              template parms because that breaks implicit typename for
6002              destructor calls.  */
6003           if (! uses_template_parms (got_object))
6004             val = from_obj;
6005         }
6006
6007       /* If we have a single function from a using decl, pull it out.  */
6008       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6009         val = OVL_FUNCTION (val);
6010     }
6011   else if (from_obj)
6012     val = from_obj;
6013
6014   return val;
6015 }
6016
6017 tree
6018 lookup_name_nonclass (name)
6019      tree name;
6020 {
6021   return lookup_name_real (name, 0, 1, 0);
6022 }
6023
6024 tree
6025 lookup_function_nonclass (name, args)
6026      tree name;
6027      tree args;
6028 {
6029   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6030 }
6031
6032 tree
6033 lookup_name_namespace_only (name)
6034      tree name;
6035 {
6036   /* type-or-namespace, nonclass, namespace_only */
6037   return lookup_name_real (name, 1, 1, 1);
6038 }
6039
6040 tree
6041 lookup_name (name, prefer_type)
6042      tree name;
6043      int prefer_type;
6044 {
6045   return lookup_name_real (name, prefer_type, 0, 0);
6046 }
6047
6048 /* Similar to `lookup_name' but look only in the innermost non-class
6049    binding level.  */
6050
6051 tree
6052 lookup_name_current_level (name)
6053      tree name;
6054 {
6055   struct binding_level *b;
6056   tree t = NULL_TREE;
6057
6058   b = current_binding_level;
6059   while (b->parm_flag == 2)
6060     b = b->level_chain;
6061
6062   if (b->namespace_p)
6063     {
6064       t = IDENTIFIER_NAMESPACE_VALUE (name);
6065
6066       /* extern "C" function() */
6067       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6068         t = TREE_VALUE (t);
6069     }
6070   else if (IDENTIFIER_BINDING (name)
6071            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6072     {
6073       while (1)
6074         {
6075           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6076             return IDENTIFIER_VALUE (name);
6077
6078           if (b->keep == 2)
6079             b = b->level_chain;
6080           else
6081             break;
6082         }
6083     }
6084
6085   return t;
6086 }
6087
6088 /* Like lookup_name_current_level, but for types.  */
6089
6090 tree
6091 lookup_type_current_level (name)
6092      tree name;
6093 {
6094   register tree t = NULL_TREE;
6095
6096   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6097
6098   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6099       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6100     {
6101       struct binding_level *b = current_binding_level;
6102       while (1)
6103         {
6104           if (purpose_member (name, b->type_shadowed))
6105             return REAL_IDENTIFIER_TYPE_VALUE (name);
6106           if (b->keep == 2)
6107             b = b->level_chain;
6108           else
6109             break;
6110         }
6111     }
6112
6113   return t;
6114 }
6115
6116 void
6117 begin_only_namespace_names ()
6118 {
6119   only_namespace_names = 1;
6120 }
6121
6122 void
6123 end_only_namespace_names ()
6124 {
6125   only_namespace_names = 0;
6126 }
6127 \f
6128 /* Push the declarations of builtin types into the namespace.
6129    RID_INDEX is the index of the builtin type
6130    in the array RID_POINTERS.  NAME is the name used when looking
6131    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6132
6133 void
6134 record_builtin_type (rid_index, name, type)
6135      enum rid rid_index;
6136      const char *name;
6137      tree type;
6138 {
6139   tree rname = NULL_TREE, tname = NULL_TREE;
6140   tree tdecl = NULL_TREE;
6141
6142   if ((int) rid_index < (int) RID_MAX)
6143     rname = ridpointers[(int) rid_index];
6144   if (name)
6145     tname = get_identifier (name);
6146
6147   TYPE_BUILT_IN (type) = 1;
6148
6149   if (tname)
6150     {
6151       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6152       set_identifier_type_value (tname, NULL_TREE);
6153       if ((int) rid_index < (int) RID_MAX)
6154         /* Built-in types live in the global namespace. */
6155         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6156     }
6157   if (rname != NULL_TREE)
6158     {
6159       if (tname != NULL_TREE)
6160         {
6161           set_identifier_type_value (rname, NULL_TREE);
6162           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6163         }
6164       else
6165         {
6166           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6167           set_identifier_type_value (rname, NULL_TREE);
6168         }
6169     }
6170 }
6171
6172 /* Record one of the standard Java types.
6173  * Declare it as having the given NAME.
6174  * If SIZE > 0, it is the size of one of the integral types;
6175  * otherwise it is the negative of the size of one of the other types.  */
6176
6177 static tree
6178 record_builtin_java_type (name, size)
6179      const char *name;
6180      int size;
6181 {
6182   tree type, decl;
6183   if (size > 0)
6184     type = make_signed_type (size);
6185   else if (size > -32)
6186     { /* "__java_char" or ""__java_boolean". */
6187       type = make_unsigned_type (-size);
6188       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6189     }
6190   else
6191     { /* "__java_float" or ""__java_double". */
6192       type = make_node (REAL_TYPE);
6193       TYPE_PRECISION (type) = - size;
6194       layout_type (type);
6195     }
6196   record_builtin_type (RID_MAX, name, type);
6197   decl = TYPE_NAME (type);
6198
6199   /* Suppress generate debug symbol entries for these types,
6200      since for normal C++ they are just clutter.
6201      However, push_lang_context undoes this if extern "Java" is seen. */
6202   DECL_IGNORED_P (decl) = 1;
6203
6204   TYPE_FOR_JAVA (type) = 1;
6205   return type;
6206 }
6207
6208 /* Push a type into the namespace so that the back-ends ignore it. */
6209
6210 static void
6211 record_unknown_type (type, name)
6212      tree type;
6213      const char *name;
6214 {
6215   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6216   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6217   DECL_IGNORED_P (decl) = 1;
6218   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6219   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6220   TYPE_ALIGN (type) = 1;
6221   TYPE_USER_ALIGN (type) = 0;
6222   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6223 }
6224
6225 /* An string for which we should create an IDENTIFIER_NODE at
6226    startup.  */
6227
6228 typedef struct predefined_identifier
6229 {
6230   /* The name of the identifier.  */
6231   const char *name;
6232   /* The place where the IDENTIFIER_NODE should be stored.  */
6233   tree *node;
6234   /* Non-zero if this is the name of a constructor or destructor.  */
6235   int ctor_or_dtor_p;
6236 } predefined_identifier;
6237
6238 /* Create all the predefined identifiers.  */
6239
6240 static void
6241 initialize_predefined_identifiers ()
6242 {
6243   struct predefined_identifier *pid;
6244
6245   /* A table of identifiers to create at startup.  */
6246   static predefined_identifier predefined_identifiers[] = {
6247     { "C++", &lang_name_cplusplus, 0 },
6248     { "C", &lang_name_c, 0 },
6249     { "Java", &lang_name_java, 0 },
6250     { CTOR_NAME, &ctor_identifier, 1 },
6251     { "__base_ctor", &base_ctor_identifier, 1 },
6252     { "__comp_ctor", &complete_ctor_identifier, 1 },
6253     { DTOR_NAME, &dtor_identifier, 1 },
6254     { "__comp_dtor", &complete_dtor_identifier, 1 },
6255     { "__base_dtor", &base_dtor_identifier, 1 },
6256     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6257     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6258     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6259     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6260     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6261     { "nelts", &nelts_identifier, 0 },
6262     { THIS_NAME, &this_identifier, 0 },
6263     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6264     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6265     { "_vptr", &vptr_identifier, 0 },
6266     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6267     { "__vtt_parm", &vtt_parm_identifier, 0 },
6268     { "std", &std_identifier, 0 },
6269     { NULL, NULL, 0 }
6270   };
6271
6272   for (pid = predefined_identifiers; pid->name; ++pid)
6273     {
6274       *pid->node = get_identifier (pid->name);
6275       if (pid->ctor_or_dtor_p)
6276         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6277     }
6278 }
6279
6280 /* Create the predefined scalar types of C,
6281    and some nodes representing standard constants (0, 1, (void *)0).
6282    Initialize the global binding level.
6283    Make definitions for built-in primitive functions.  */
6284
6285 void
6286 init_decl_processing ()
6287 {
6288   tree fields[20];
6289
6290   /* Check to see that the user did not specify an invalid combination
6291      of command-line options.  */
6292   if (flag_new_abi && !flag_vtable_thunks)
6293     fatal ("the new ABI requires vtable thunks");
6294
6295   /* Create all the identifiers we need.  */
6296   initialize_predefined_identifiers ();
6297
6298   /* Fill in back-end hooks.  */
6299   init_lang_status = &push_cp_function_context;
6300   free_lang_status = &pop_cp_function_context;
6301   mark_lang_status = &mark_cp_function_context;
6302   lang_safe_from_p = &c_safe_from_p;
6303   lang_dump_tree = &cp_dump_tree;
6304   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6305
6306   cp_parse_init ();
6307   init_decl2 ();
6308   init_pt ();
6309
6310   /* Create the global variables.  */
6311   push_to_top_level ();
6312
6313   /* Enter the global namespace. */
6314   my_friendly_assert (global_namespace == NULL_TREE, 375);
6315   push_namespace (get_identifier ("::"));
6316   global_namespace = current_namespace;
6317   current_lang_name = NULL_TREE;
6318
6319   /* Adjust various flags based on command-line settings.  */
6320   if (! flag_permissive && ! pedantic)
6321     flag_pedantic_errors = 1;
6322   if (!flag_no_inline)
6323     flag_inline_trees = 1;
6324
6325   /* Initially, C.  */
6326   current_lang_name = lang_name_c;
6327
6328   current_function_decl = NULL_TREE;
6329   current_binding_level = NULL_BINDING_LEVEL;
6330   free_binding_level = NULL_BINDING_LEVEL;
6331
6332   build_common_tree_nodes (flag_signed_char);
6333
6334   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6335   TREE_TYPE (error_mark_list) = error_mark_node;
6336
6337   /* Make the binding_level structure for global names.  */
6338   pushlevel (0);
6339   global_binding_level = current_binding_level;
6340   /* The global level is the namespace level of ::.  */
6341   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6342   declare_namespace_level ();
6343
6344   /* Create the `std' namespace.  */
6345   if (flag_honor_std)
6346     {
6347       push_namespace (std_identifier);
6348       std_node = current_namespace;
6349       pop_namespace ();
6350       fake_std_node = error_mark_node;
6351     }
6352   else
6353     {
6354       fake_std_node = build_decl (NAMESPACE_DECL,
6355                                   std_identifier,
6356                                   void_type_node);
6357       pushdecl (fake_std_node);
6358     }
6359
6360   c_common_nodes_and_builtins ();
6361
6362   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6363   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6364   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6365   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6366   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6367   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6368   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6369   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6370
6371   integer_two_node = build_int_2 (2, 0);
6372   TREE_TYPE (integer_two_node) = integer_type_node;
6373   integer_three_node = build_int_2 (3, 0);
6374   TREE_TYPE (integer_three_node) = integer_type_node;
6375
6376   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6377   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6378   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6379   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6380   TYPE_PRECISION (boolean_type_node) = 1;
6381   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6382   boolean_false_node = build_int_2 (0, 0);
6383   TREE_TYPE (boolean_false_node) = boolean_type_node;
6384   boolean_true_node = build_int_2 (1, 0);
6385   TREE_TYPE (boolean_true_node) = boolean_type_node;
6386
6387   signed_size_zero_node = build_int_2 (0, 0);
6388   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6389
6390   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6391
6392 #if 0
6393   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6394 #endif
6395
6396   if (flag_new_abi)
6397     delta_type_node = ptrdiff_type_node;
6398   else if (flag_huge_objects)
6399     delta_type_node = long_integer_type_node;
6400   else
6401     delta_type_node = short_integer_type_node;
6402
6403   if (flag_new_abi)
6404     vtable_index_type = ptrdiff_type_node;
6405   else
6406     vtable_index_type = delta_type_node;
6407
6408   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6409   lang_type_promotes_to = convert_type_from_ellipsis;
6410
6411   void_ftype_ptr
6412     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6413
6414   /* C++ extensions */
6415
6416   unknown_type_node = make_node (UNKNOWN_TYPE);
6417   record_unknown_type (unknown_type_node, "unknown type");
6418
6419   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6420   TREE_TYPE (unknown_type_node) = unknown_type_node;
6421
6422   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6423
6424   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6425      result.  */
6426   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6427   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6428
6429   if (flag_vtable_thunks)
6430     {
6431       /* Make sure we get a unique function type, so we can give
6432          its pointer type a name.  (This wins for gdb.) */
6433       tree vfunc_type = make_node (FUNCTION_TYPE);
6434       TREE_TYPE (vfunc_type) = integer_type_node;
6435       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6436       layout_type (vfunc_type);
6437
6438       vtable_entry_type = build_pointer_type (vfunc_type);
6439     }
6440   else
6441     {
6442       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6443       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6444                               delta_type_node);
6445       fields[1] = build_decl (FIELD_DECL, index_identifier,
6446                               delta_type_node);
6447       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6448                               ptr_type_node);
6449       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6450                            double_type_node);
6451
6452       /* Make this part of an invisible union.  */
6453       fields[3] = copy_node (fields[2]);
6454       TREE_TYPE (fields[3]) = delta_type_node;
6455       DECL_NAME (fields[3]) = delta2_identifier;
6456       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6457       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6458       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6459       TREE_UNSIGNED (fields[3]) = 0;
6460       TREE_CHAIN (fields[2]) = fields[3];
6461       vtable_entry_type = build_qualified_type (vtable_entry_type,
6462                                                 TYPE_QUAL_CONST);
6463     }
6464   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6465
6466   vtbl_type_node
6467     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6468   layout_type (vtbl_type_node);
6469   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6470   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6471   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6472   layout_type (vtbl_ptr_type_node);
6473   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6474
6475   if (flag_new_abi)
6476     {
6477       push_namespace (get_identifier ("__cxxabiv1"));
6478       abi_node = current_namespace;
6479       pop_namespace ();
6480     }
6481
6482   global_type_node = make_node (LANG_TYPE);
6483   record_unknown_type (global_type_node, "global type");
6484
6485   /* Now, C++.  */
6486   current_lang_name = lang_name_cplusplus;
6487
6488   {
6489     tree bad_alloc_type_node, newtype, deltype;
6490     if (flag_honor_std)
6491       push_namespace (std_identifier);
6492     bad_alloc_type_node = xref_tag
6493       (class_type_node, get_identifier ("bad_alloc"), 1);
6494     if (flag_honor_std)
6495       pop_namespace ();
6496     newtype = build_exception_variant
6497       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6498     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6499     push_cp_library_fn (NEW_EXPR, newtype);
6500     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6501     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6502     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6503   }
6504
6505   abort_fndecl
6506     = build_library_fn_ptr ((flag_new_abi
6507                              ? "__cxa_pure_virtual"
6508                              : "__pure_virtual"),
6509                             void_ftype);
6510
6511   /* Perform other language dependent initializations.  */
6512   init_class_processing ();
6513   init_init_processing ();
6514   init_search_processing ();
6515   init_rtti_processing ();
6516
6517   if (flag_exceptions)
6518     init_exception_processing ();
6519   if (flag_no_inline)
6520     {
6521       flag_inline_functions = 0;
6522     }
6523
6524   if (! supports_one_only ())
6525     flag_weak = 0;
6526
6527   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6528   function_id_node = get_identifier ("__FUNCTION__");
6529   pretty_function_id_node = get_identifier ("__PRETTY_FUNCTION__");
6530   func_id_node = get_identifier ("__func__");
6531
6532   make_fname_decl = cp_make_fname_decl;
6533   declare_function_name ();
6534
6535   /* Prepare to check format strings against argument lists.  */
6536   init_function_format_info ();
6537
6538   /* Show we use EH for cleanups.  */
6539   using_eh_for_cleanups ();
6540
6541   valid_lang_attribute = cp_valid_lang_attribute;
6542
6543   /* Maintain consistency.  Perhaps we should just complain if they
6544      say -fwritable-strings?  */
6545   if (flag_writable_strings)
6546     flag_const_strings = 0;
6547
6548   /* Add GC roots for all of our global variables.  */
6549   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6550   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6551   ggc_add_tree_root (&integer_three_node, 1);
6552   ggc_add_tree_root (&integer_two_node, 1);
6553   ggc_add_tree_root (&signed_size_zero_node, 1);
6554   ggc_add_tree_root (&size_one_node, 1);
6555   ggc_add_tree_root (&size_zero_node, 1);
6556   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6557                 mark_binding_level);
6558   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6559   ggc_add_tree_root (&static_ctors, 1);
6560   ggc_add_tree_root (&static_dtors, 1);
6561   ggc_add_tree_root (&lastiddecl, 1);
6562
6563   ggc_add_tree_root (&last_function_parm_tags, 1);
6564   ggc_add_tree_root (&current_function_return_value, 1);
6565   ggc_add_tree_root (&current_function_parm_tags, 1);
6566   ggc_add_tree_root (&last_function_parms, 1);
6567   ggc_add_tree_root (&error_mark_list, 1);
6568
6569   ggc_add_tree_root (&global_namespace, 1);
6570   ggc_add_tree_root (&global_type_node, 1);
6571   ggc_add_tree_root (&anonymous_namespace_name, 1);
6572
6573   ggc_add_tree_root (&got_object, 1);
6574   ggc_add_tree_root (&got_scope, 1);
6575
6576   ggc_add_tree_root (&current_lang_name, 1);
6577   ggc_add_tree_root (&static_aggregates, 1);
6578   ggc_add_tree_root (&free_bindings, 1);
6579 }
6580
6581 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6582    decl, NAME is the initialization string and TYPE_DEP indicates whether
6583    NAME depended on the type of the function. We make use of that to detect
6584    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6585    the function before emitting any of it, we don't need to treat the
6586    VAR_DECL specially. We can decide whether to emit it later, if it was
6587    used.  */
6588
6589 static tree
6590 cp_make_fname_decl (id, name, type_dep)
6591      tree id;
6592      const char *name;
6593      int type_dep;
6594 {
6595   tree decl, type, init;
6596   size_t length = strlen (name);
6597   tree domain = NULL_TREE;
6598
6599   if (!processing_template_decl)
6600     type_dep = 0;
6601   if (!type_dep)
6602     domain = build_index_type (size_int (length));
6603
6604   type =  build_cplus_array_type
6605           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6606            domain);
6607
6608   decl = build_decl (VAR_DECL, id, type);
6609   TREE_STATIC (decl) = 1;
6610   TREE_READONLY (decl) = 1;
6611   DECL_SOURCE_LINE (decl) = 0;
6612   DECL_ARTIFICIAL (decl) = 1;
6613   DECL_IN_SYSTEM_HEADER (decl) = 1;
6614   pushdecl (decl);
6615   if (processing_template_decl)
6616     decl = push_template_decl (decl);
6617   if (type_dep)
6618     {
6619       init = build (FUNCTION_NAME, type);
6620       DECL_PRETTY_FUNCTION_P (decl) = 1;
6621     }
6622   else
6623     {
6624       init = build_string (length + 1, name);
6625       TREE_TYPE (init) = type;
6626     }
6627   DECL_INITIAL (decl) = init;
6628   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6629
6630   /* We will have to make sure we only emit this, if it is actually used. */
6631   return decl;
6632 }
6633
6634 /* Entry point for the benefit of c_common_nodes_and_builtins.
6635
6636    Make a definition for a builtin function named NAME and whose data type
6637    is TYPE.  TYPE should be a function type with argument types.
6638
6639    CLASS and CODE tell later passes how to compile calls to this function.
6640    See tree.h for possible values.
6641
6642    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6643    the name to be called if we can't opencode the function.  */
6644
6645 tree
6646 builtin_function (name, type, code, class, libname)
6647      const char *name;
6648      tree type;
6649      int code;
6650      enum built_in_class class;
6651      const char *libname;
6652 {
6653   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6654   DECL_BUILT_IN_CLASS (decl) = class;
6655   DECL_FUNCTION_CODE (decl) = code;
6656
6657   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6658
6659   /* All builtins that don't begin with an `_' should go in the `std'
6660      namespace.  */
6661   if (flag_honor_std && name[0] != '_')
6662     {
6663       push_namespace (std_identifier);
6664       DECL_CONTEXT (decl) = std_node;
6665     }
6666   pushdecl (decl);
6667   if (flag_honor_std && name[0] != '_')
6668     pop_namespace ();
6669
6670   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6671      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6672      function in the namespace.  */
6673   if (libname)
6674     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6675   make_decl_rtl (decl, NULL);
6676
6677   /* Warn if a function in the namespace for users
6678      is used without an occasion to consider it declared.  */
6679   if (name[0] != '_' || name[1] != '_')
6680     DECL_ANTICIPATED (decl) = 1;
6681
6682   return decl;
6683 }
6684
6685 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6686    function.  Not called directly.  */
6687
6688 static tree
6689 build_library_fn_1 (name, operator_code, type)
6690      tree name;
6691      enum tree_code operator_code;
6692      tree type;
6693 {
6694   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6695   DECL_EXTERNAL (fn) = 1;
6696   TREE_PUBLIC (fn) = 1;
6697   DECL_ARTIFICIAL (fn) = 1;
6698   TREE_NOTHROW (fn) = 1;
6699   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6700   return fn;
6701 }
6702
6703 /* Returns the _DECL for a library function with C linkage.
6704    We assume that such functions never throw; if this is incorrect,
6705    callers should unset TREE_NOTHROW.  */
6706
6707 tree
6708 build_library_fn (name, type)
6709      tree name;
6710      tree type;
6711 {
6712   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6713   make_decl_rtl (fn, NULL);
6714   return fn;
6715 }
6716
6717 /* Returns the _DECL for a library function with C++ linkage.  */
6718
6719 static tree
6720 build_cp_library_fn (name, operator_code, type)
6721      tree name;
6722      enum tree_code operator_code;
6723      tree type;
6724 {
6725   tree fn = build_library_fn_1 (name, operator_code, type);
6726   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6727   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6728   set_mangled_name_for_decl (fn);
6729   make_decl_rtl (fn, NULL);
6730   return fn;
6731 }
6732
6733 /* Like build_library_fn, but takes a C string instead of an
6734    IDENTIFIER_NODE.  */
6735
6736 tree
6737 build_library_fn_ptr (name, type)
6738      const char *name;
6739      tree type;
6740 {
6741   return build_library_fn (get_identifier (name), type);
6742 }
6743
6744 /* Like build_cp_library_fn, but takes a C string instead of an
6745    IDENTIFIER_NODE.  */
6746
6747 tree
6748 build_cp_library_fn_ptr (name, type)
6749      const char *name;
6750      tree type;
6751 {
6752   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6753 }
6754
6755 /* Like build_library_fn, but also pushes the function so that we will
6756    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6757
6758 tree
6759 push_library_fn (name, type)
6760      tree name, type;
6761 {
6762   tree fn = build_library_fn (name, type);
6763   pushdecl_top_level (fn);
6764   return fn;
6765 }
6766
6767 /* Like build_cp_library_fn, but also pushes the function so that it
6768    will be found by normal lookup.  */
6769
6770 static tree
6771 push_cp_library_fn (operator_code, type)
6772      enum tree_code operator_code;
6773      tree type;
6774 {
6775   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6776                                  operator_code,
6777                                  type);
6778   pushdecl (fn);
6779   return fn;
6780 }
6781
6782 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6783    a FUNCTION_TYPE.  */
6784
6785 tree
6786 push_void_library_fn (name, parmtypes)
6787      tree name, parmtypes;
6788 {
6789   tree type = build_function_type (void_type_node, parmtypes);
6790   return push_library_fn (name, type);
6791 }
6792
6793 /* Like push_library_fn, but also note that this function throws
6794    and does not return.  Used for __throw_foo and the like.  */
6795
6796 tree
6797 push_throw_library_fn (name, type)
6798      tree name, type;
6799 {
6800   tree fn = push_library_fn (name, type);
6801   TREE_THIS_VOLATILE (fn) = 1;
6802   TREE_NOTHROW (fn) = 0;
6803   return fn;
6804 }
6805 \f
6806 /* When we call finish_struct for an anonymous union, we create
6807    default copy constructors and such.  But, an anonymous union
6808    shouldn't have such things; this function undoes the damage to the
6809    anonymous union type T.
6810
6811    (The reason that we create the synthesized methods is that we don't
6812    distinguish `union { int i; }' from `typedef union { int i; } U'.
6813    The first is an anonymous union; the second is just an ordinary
6814    union type.)  */
6815
6816 void
6817 fixup_anonymous_aggr (t)
6818      tree t;
6819 {
6820   tree *q;
6821
6822   /* Wipe out memory of synthesized methods */
6823   TYPE_HAS_CONSTRUCTOR (t) = 0;
6824   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6825   TYPE_HAS_INIT_REF (t) = 0;
6826   TYPE_HAS_CONST_INIT_REF (t) = 0;
6827   TYPE_HAS_ASSIGN_REF (t) = 0;
6828   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6829
6830   /* Splice the implicitly generated functions out of the TYPE_METHODS
6831      list.  */
6832   q = &TYPE_METHODS (t);
6833   while (*q)
6834     {
6835       if (DECL_ARTIFICIAL (*q))
6836         *q = TREE_CHAIN (*q);
6837       else
6838         q = &TREE_CHAIN (*q);
6839     }
6840
6841   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6842   if (TYPE_METHODS (t))
6843     cp_error_at ("an anonymous union cannot have function members", t);
6844 }
6845
6846 /* Make sure that a declaration with no declarator is well-formed, i.e.
6847    just defines a tagged type or anonymous union.
6848
6849    Returns the type defined, if any.  */
6850
6851 tree
6852 check_tag_decl (declspecs)
6853      tree declspecs;
6854 {
6855   int found_type = 0;
6856   int saw_friend = 0;
6857   tree ob_modifier = NULL_TREE;
6858   register tree link;
6859   register tree t = NULL_TREE;
6860
6861   for (link = declspecs; link; link = TREE_CHAIN (link))
6862     {
6863       register tree value = TREE_VALUE (link);
6864
6865       if (TYPE_P (value)
6866           || (TREE_CODE (value) == IDENTIFIER_NODE
6867               && IDENTIFIER_GLOBAL_VALUE (value)
6868               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6869         {
6870           ++found_type;
6871
6872           if ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6873               || TREE_CODE (value) == ENUMERAL_TYPE)
6874             {
6875               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6876               t = value;
6877             }
6878         }
6879       else if (value == ridpointers[(int) RID_FRIEND])
6880         {
6881           if (current_class_type == NULL_TREE
6882               || current_scope () != current_class_type)
6883             ob_modifier = value;
6884           else
6885             saw_friend = 1;
6886         }
6887       else if (value == ridpointers[(int) RID_STATIC]
6888                || value == ridpointers[(int) RID_EXTERN]
6889                || value == ridpointers[(int) RID_AUTO]
6890                || value == ridpointers[(int) RID_REGISTER]
6891                || value == ridpointers[(int) RID_INLINE]
6892                || value == ridpointers[(int) RID_VIRTUAL]
6893                || value == ridpointers[(int) RID_CONST]
6894                || value == ridpointers[(int) RID_VOLATILE]
6895                || value == ridpointers[(int) RID_EXPLICIT])
6896         ob_modifier = value;
6897     }
6898
6899   if (found_type > 1)
6900     error ("multiple types in one declaration");
6901
6902   if (t == NULL_TREE && ! saw_friend)
6903     pedwarn ("declaration does not declare anything");
6904
6905   /* Check for an anonymous union.  We're careful
6906      accessing TYPE_IDENTIFIER because some built-in types, like
6907      pointer-to-member types, do not have TYPE_NAME.  */
6908   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6909            && TYPE_NAME (t)
6910            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6911     {
6912       /* Anonymous unions are objects, so they can have specifiers.  */;
6913       SET_ANON_AGGR_TYPE_P (t);
6914
6915       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6916         pedwarn ("ISO C++ prohibits anonymous structs");
6917     }
6918
6919   else if (ob_modifier)
6920     {
6921       if (ob_modifier == ridpointers[(int) RID_INLINE]
6922           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6923         cp_error ("`%D' can only be specified for functions", ob_modifier);
6924       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6925         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6926       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6927         cp_error ("`%D' can only be specified for constructors",
6928                   ob_modifier);
6929       else
6930         cp_error ("`%D' can only be specified for objects and functions",
6931                   ob_modifier);
6932     }
6933
6934   return t;
6935 }
6936
6937 /* Called when a declaration is seen that contains no names to declare.
6938    If its type is a reference to a structure, union or enum inherited
6939    from a containing scope, shadow that tag name for the current scope
6940    with a forward reference.
6941    If its type defines a new named structure or union
6942    or defines an enum, it is valid but we need not do anything here.
6943    Otherwise, it is an error.
6944
6945    C++: may have to grok the declspecs to learn about static,
6946    complain for anonymous unions.  */
6947
6948 void
6949 shadow_tag (declspecs)
6950      tree declspecs;
6951 {
6952   tree t = check_tag_decl (declspecs);
6953
6954   if (t)
6955     maybe_process_partial_specialization (t);
6956
6957   /* This is where the variables in an anonymous union are
6958      declared.  An anonymous union declaration looks like:
6959      union { ... } ;
6960      because there is no declarator after the union, the parser
6961      sends that declaration here.  */
6962   if (t && ANON_AGGR_TYPE_P (t))
6963     {
6964       fixup_anonymous_aggr (t);
6965
6966       if (TYPE_FIELDS (t))
6967         {
6968           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6969                                       NULL_TREE);
6970           finish_anon_union (decl);
6971         }
6972     }
6973 }
6974 \f
6975 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6976
6977 tree
6978 groktypename (typename)
6979      tree typename;
6980 {
6981   if (TREE_CODE (typename) != TREE_LIST)
6982     return typename;
6983   return grokdeclarator (TREE_VALUE (typename),
6984                          TREE_PURPOSE (typename),
6985                          TYPENAME, 0, NULL_TREE);
6986 }
6987
6988 /* Decode a declarator in an ordinary declaration or data definition.
6989    This is called as soon as the type information and variable name
6990    have been parsed, before parsing the initializer if any.
6991    Here we create the ..._DECL node, fill in its type,
6992    and put it on the list of decls for the current context.
6993    The ..._DECL node is returned as the value.
6994
6995    Exception: for arrays where the length is not specified,
6996    the type is left null, to be filled in by `cp_finish_decl'.
6997
6998    Function definitions do not come here; they go to start_function
6999    instead.  However, external and forward declarations of functions
7000    do go through here.  Structure field declarations are done by
7001    grokfield and not through here.  */
7002
7003 tree
7004 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7005      tree declarator, declspecs;
7006      int initialized;
7007      tree attributes, prefix_attributes;
7008 {
7009   register tree decl;
7010   register tree type, tem;
7011   tree context;
7012   extern int have_extern_spec;
7013   extern int used_extern_spec;
7014   tree attrlist;
7015
7016 #if 0
7017   /* See code below that used this.  */
7018   int init_written = initialized;
7019 #endif
7020
7021   /* This should only be done once on the top most decl.  */
7022   if (have_extern_spec && !used_extern_spec)
7023     {
7024       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7025                              declspecs);
7026       used_extern_spec = 1;
7027     }
7028
7029   if (attributes || prefix_attributes)
7030     attrlist = build_tree_list (attributes, prefix_attributes);
7031   else
7032     attrlist = NULL_TREE;
7033
7034   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7035                          attrlist);
7036
7037   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7038     return NULL_TREE;
7039
7040   type = TREE_TYPE (decl);
7041
7042   if (type == error_mark_node)
7043     return NULL_TREE;
7044
7045   context = DECL_CONTEXT (decl);
7046
7047   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7048       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7049     {
7050       /* When parsing the initializer, lookup should use the object's
7051          namespace. */
7052       push_decl_namespace (context);
7053     }
7054
7055   /* We are only interested in class contexts, later. */
7056   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7057     context = NULL_TREE;
7058
7059   if (initialized)
7060     /* Is it valid for this decl to have an initializer at all?
7061        If not, set INITIALIZED to zero, which will indirectly
7062        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7063     switch (TREE_CODE (decl))
7064       {
7065       case TYPE_DECL:
7066         /* typedef foo = bar  means give foo the same type as bar.
7067            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7068            Any other case of an initialization in a TYPE_DECL is an error.  */
7069         if (pedantic || list_length (declspecs) > 1)
7070           {
7071             cp_error ("typedef `%D' is initialized", decl);
7072             initialized = 0;
7073           }
7074         break;
7075
7076       case FUNCTION_DECL:
7077         cp_error ("function `%#D' is initialized like a variable", decl);
7078         initialized = 0;
7079         break;
7080
7081       default:
7082         break;
7083       }
7084
7085   if (initialized)
7086     {
7087       if (! toplevel_bindings_p ()
7088           && DECL_EXTERNAL (decl))
7089         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7090                     decl);
7091       DECL_EXTERNAL (decl) = 0;
7092       if (toplevel_bindings_p ())
7093         TREE_STATIC (decl) = 1;
7094
7095       /* Tell `pushdecl' this is an initialized decl
7096          even though we don't yet have the initializer expression.
7097          Also tell `cp_finish_decl' it may store the real initializer.  */
7098       DECL_INITIAL (decl) = error_mark_node;
7099     }
7100
7101 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7102   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7103 #endif
7104
7105   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7106   cplus_decl_attributes (decl, attributes, prefix_attributes);
7107
7108   if (context && COMPLETE_TYPE_P (complete_type (context)))
7109     {
7110       push_nested_class (context, 2);
7111
7112       if (TREE_CODE (decl) == VAR_DECL)
7113         {
7114           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7115           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7116             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7117           else
7118             {
7119               if (DECL_CONTEXT (field) != context)
7120                 {
7121                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7122                               DECL_CONTEXT (field), DECL_NAME (decl),
7123                               context, DECL_NAME (decl));
7124                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7125                 }
7126               /* Static data member are tricky; an in-class initialization
7127                  still doesn't provide a definition, so the in-class
7128                  declaration will have DECL_EXTERNAL set, but will have an
7129                  initialization.  Thus, duplicate_decls won't warn
7130                  about this situation, and so we check here.  */
7131               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7132                 cp_error ("duplicate initialization of %D", decl);
7133               if (duplicate_decls (decl, field))
7134                 decl = field;
7135             }
7136         }
7137       else
7138         {
7139           tree field = check_classfn (context, decl);
7140           if (field && duplicate_decls (decl, field))
7141             decl = field;
7142         }
7143
7144       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7145       DECL_IN_AGGR_P (decl) = 0;
7146       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7147           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7148         {
7149           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7150           /* [temp.expl.spec] An explicit specialization of a static data
7151              member of a template is a definition if the declaration
7152              includes an initializer; otherwise, it is a declaration.
7153
7154              We check for processing_specialization so this only applies
7155              to the new specialization syntax.  */
7156           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7157             DECL_EXTERNAL (decl) = 1;
7158         }
7159
7160       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7161         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7162                     decl);
7163     }
7164
7165   /* Enter this declaration into the symbol table.  */
7166   tem = maybe_push_decl (decl);
7167
7168   if (processing_template_decl)
7169     tem = push_template_decl (tem);
7170
7171 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7172   /* Tell the back-end to use or not use .common as appropriate.  If we say
7173      -fconserve-space, we want this to save .data space, at the expense of
7174      wrong semantics.  If we say -fno-conserve-space, we want this to
7175      produce errors about redefs; to do this we force variables into the
7176      data segment.  */
7177   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7178 #endif
7179
7180   if (! processing_template_decl)
7181     start_decl_1 (tem);
7182
7183   return tem;
7184 }
7185
7186 void
7187 start_decl_1 (decl)
7188      tree decl;
7189 {
7190   tree type = TREE_TYPE (decl);
7191   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7192
7193   if (type == error_mark_node)
7194     return;
7195
7196   /* If this type of object needs a cleanup, but we're not allowed to
7197      add any more objects with cleanups to the current scope, create a
7198      new binding level.  */
7199   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7200       && current_binding_level->more_cleanups_ok == 0)
7201     {
7202       keep_next_level (2);
7203       pushlevel (1);
7204       clear_last_expr ();
7205       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7206     }
7207
7208   if (initialized)
7209     /* Is it valid for this decl to have an initializer at all?
7210        If not, set INITIALIZED to zero, which will indirectly
7211        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7212     {
7213       /* Don't allow initializations for incomplete types except for
7214          arrays which might be completed by the initialization.  */
7215       if (COMPLETE_TYPE_P (complete_type (type)))
7216         ;                       /* A complete type is ok.  */
7217       else if (TREE_CODE (type) != ARRAY_TYPE)
7218         {
7219           cp_error ("variable `%#D' has initializer but incomplete type",
7220                     decl);
7221           initialized = 0;
7222           type = TREE_TYPE (decl) = error_mark_node;
7223         }
7224       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7225         {
7226           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7227             cp_error ("elements of array `%#D' have incomplete type", decl);
7228           /* else we already gave an error in start_decl.  */
7229           initialized = 0;
7230         }
7231     }
7232
7233   if (!initialized
7234       && TREE_CODE (decl) != TYPE_DECL
7235       && TREE_CODE (decl) != TEMPLATE_DECL
7236       && type != error_mark_node
7237       && IS_AGGR_TYPE (type)
7238       && ! DECL_EXTERNAL (decl))
7239     {
7240       if ((! processing_template_decl || ! uses_template_parms (type))
7241           && !COMPLETE_TYPE_P (complete_type (type)))
7242         {
7243           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7244                  decl);
7245           /* Change the type so that assemble_variable will give
7246              DECL an rtl we can live with: (mem (const_int 0)).  */
7247           type = TREE_TYPE (decl) = error_mark_node;
7248         }
7249       else
7250         {
7251           /* If any base type in the hierarchy of TYPE needs a constructor,
7252              then we set initialized to 1.  This way any nodes which are
7253              created for the purposes of initializing this aggregate
7254              will live as long as it does.  This is necessary for global
7255              aggregates which do not have their initializers processed until
7256              the end of the file.  */
7257           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7258         }
7259     }
7260
7261   if (! initialized)
7262     DECL_INITIAL (decl) = NULL_TREE;
7263 }
7264
7265 /* Handle initialization of references.
7266    These three arguments are from `cp_finish_decl', and have the
7267    same meaning here that they do there.
7268
7269    Quotes on semantics can be found in ARM 8.4.3.  */
7270
7271 static void
7272 grok_reference_init (decl, type, init)
7273      tree decl, type, init;
7274 {
7275   tree tmp;
7276
7277   if (init == NULL_TREE)
7278     {
7279       if ((DECL_LANG_SPECIFIC (decl) == 0
7280            || DECL_IN_AGGR_P (decl) == 0)
7281           && ! DECL_THIS_EXTERN (decl))
7282         cp_error ("`%D' declared as reference but not initialized", decl);
7283       return;
7284     }
7285
7286   if (init == error_mark_node)
7287     return;
7288
7289   if (TREE_CODE (init) == CONSTRUCTOR)
7290     {
7291       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7292       return;
7293     }
7294
7295   if (TREE_CODE (init) == TREE_LIST)
7296     init = build_compound_expr (init);
7297
7298   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7299     init = convert_from_reference (init);
7300
7301   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7302       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7303     {
7304       /* Note: default conversion is only called in very special cases.  */
7305       init = default_conversion (init);
7306     }
7307
7308   /* Convert INIT to the reference type TYPE.  This may involve the
7309      creation of a temporary, whose lifetime must be the same as that
7310      of the reference.  If so, a DECL_STMT for the temporary will be
7311      added just after the DECL_STMT for DECL.  That's why we don't set
7312      DECL_INITIAL for local references (instead assigning to them
7313      explicitly); we need to allow the temporary to be initialized
7314      first.  */
7315   tmp = convert_to_reference
7316     (type, init, CONV_IMPLICIT,
7317      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7318      decl);
7319
7320   if (tmp == error_mark_node)
7321     return;
7322   else if (tmp != NULL_TREE)
7323     {
7324       init = tmp;
7325       tmp = save_expr (tmp);
7326       if (building_stmt_tree ())
7327         {
7328           /* Initialize the declaration.  */
7329           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7330           finish_expr_stmt (tmp);
7331         }
7332       else
7333         DECL_INITIAL (decl) = tmp;
7334     }
7335   else
7336     {
7337       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7338       return;
7339     }
7340
7341   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7342     {
7343       expand_static_init (decl, DECL_INITIAL (decl));
7344       DECL_INITIAL (decl) = NULL_TREE;
7345     }
7346   return;
7347 }
7348
7349 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7350    mucking with forces it does not comprehend (i.e. initialization with a
7351    constructor).  If we are at global scope and won't go into COMMON, fill
7352    it in with a dummy CONSTRUCTOR to force the variable into .data;
7353    otherwise we can use error_mark_node.  */
7354
7355 static tree
7356 obscure_complex_init (decl, init)
7357      tree decl, init;
7358 {
7359   if (! flag_no_inline && TREE_STATIC (decl))
7360     {
7361       if (extract_init (decl, init))
7362         return NULL_TREE;
7363     }
7364
7365 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7366   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7367     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7368                                  NULL_TREE);
7369   else
7370 #endif
7371     DECL_INITIAL (decl) = error_mark_node;
7372
7373   return init;
7374 }
7375
7376 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7377    array until we finish parsing the initializer.  If that's the
7378    situation we're in, update DECL accordingly.  */
7379
7380 static void
7381 maybe_deduce_size_from_array_init (decl, init)
7382      tree decl;
7383      tree init;
7384 {
7385   tree type = TREE_TYPE (decl);
7386
7387   if (TREE_CODE (type) == ARRAY_TYPE
7388       && TYPE_DOMAIN (type) == NULL_TREE
7389       && TREE_CODE (decl) != TYPE_DECL)
7390     {
7391       /* do_default is really a C-ism to deal with tentative definitions.
7392          But let's leave it here to ease the eventual merge.  */
7393       int do_default = !DECL_EXTERNAL (decl);
7394       tree initializer = init ? init : DECL_INITIAL (decl);
7395       int failure = complete_array_type (type, initializer, do_default);
7396
7397       if (failure == 1)
7398         cp_error ("initializer fails to determine size of `%D'", decl);
7399
7400       if (failure == 2)
7401         {
7402           if (do_default)
7403             cp_error ("array size missing in `%D'", decl);
7404           /* If a `static' var's size isn't known, make it extern as
7405              well as static, so it does not get allocated.  If it's not
7406              `static', then don't mark it extern; finish_incomplete_decl
7407              will give it a default size and it will get allocated.  */
7408           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7409             DECL_EXTERNAL (decl) = 1;
7410         }
7411
7412       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7413           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7414                               integer_zero_node))
7415         cp_error ("zero-size array `%D'", decl);
7416
7417       layout_decl (decl, 0);
7418     }
7419 }
7420
7421 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7422    any appropriate error messages regarding the layout.  */
7423
7424 static void
7425 layout_var_decl (decl)
7426      tree decl;
7427 {
7428   tree type = TREE_TYPE (decl);
7429 #if 0
7430   tree ttype = target_type (type);
7431 #endif
7432
7433   /* If we haven't already layed out this declaration, do so now.
7434      Note that we must not call complete type for an external object
7435      because it's type might involve templates that we are not
7436      supposed to isntantiate yet.  (And it's perfectly legal to say
7437      `extern X x' for some incomplete type `X'.)  */
7438   if (!DECL_EXTERNAL (decl))
7439     complete_type (type);
7440   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7441     layout_decl (decl, 0);
7442
7443   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7444     {
7445       /* An automatic variable with an incomplete type: that is an error.
7446          Don't talk about array types here, since we took care of that
7447          message in grokdeclarator.  */
7448       cp_error ("storage size of `%D' isn't known", decl);
7449       TREE_TYPE (decl) = error_mark_node;
7450     }
7451 #if 0
7452   /* Keep this code around in case we later want to control debug info
7453      based on whether a type is "used".  (jason 1999-11-11) */
7454
7455   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7456     /* Let debugger know it should output info for this type.  */
7457     note_debug_info_needed (ttype);
7458
7459   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7460     note_debug_info_needed (DECL_CONTEXT (decl));
7461 #endif
7462
7463   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7464       && DECL_SIZE (decl) != NULL_TREE
7465       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7466     {
7467       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7468         constant_expression_warning (DECL_SIZE (decl));
7469       else
7470         cp_error ("storage size of `%D' isn't constant", decl);
7471     }
7472 }
7473
7474 /* If a local static variable is declared in an inline function, or if
7475    we have a weak definition, we must endeavor to create only one
7476    instance of the variable at link-time.  */
7477
7478 static void
7479 maybe_commonize_var (decl)
7480      tree decl;
7481 {
7482   /* Static data in a function with comdat linkage also has comdat
7483      linkage.  */
7484   if (TREE_STATIC (decl)
7485       /* Don't mess with __FUNCTION__.  */
7486       && ! DECL_ARTIFICIAL (decl)
7487       && current_function_decl
7488       && DECL_CONTEXT (decl) == current_function_decl
7489       && (DECL_THIS_INLINE (current_function_decl)
7490           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7491       && TREE_PUBLIC (current_function_decl))
7492     {
7493       /* Rather than try to get this right with inlining, we suppress
7494          inlining of such functions.  */
7495       current_function_cannot_inline
7496         = "function with static variable cannot be inline";
7497       DECL_UNINLINABLE (current_function_decl) = 1;
7498
7499       /* If flag_weak, we don't need to mess with this, as we can just
7500          make the function weak, and let it refer to its unique local
7501          copy.  This works because we don't allow the function to be
7502          inlined.  */
7503       if (! flag_weak)
7504         {
7505           if (DECL_INTERFACE_KNOWN (current_function_decl))
7506             {
7507               TREE_PUBLIC (decl) = 1;
7508               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7509             }
7510           else if (DECL_INITIAL (decl) == NULL_TREE
7511                    || DECL_INITIAL (decl) == error_mark_node)
7512             {
7513               TREE_PUBLIC (decl) = 1;
7514               DECL_COMMON (decl) = 1;
7515             }
7516           /* else we lose. We can only do this if we can use common,
7517              which we can't if it has been initialized.  */
7518
7519           if (TREE_PUBLIC (decl))
7520             DECL_ASSEMBLER_NAME (decl)
7521               = build_static_name (current_function_decl, DECL_NAME (decl));
7522           else
7523             {
7524               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7525               cp_warning_at ("  you can work around this by removing the initializer", decl);
7526             }
7527         }
7528     }
7529   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7530     /* Set it up again; we might have set DECL_INITIAL since the last
7531        time.  */
7532     comdat_linkage (decl);
7533 }
7534
7535 /* Issue an error message if DECL is an uninitialized const variable.  */
7536
7537 static void
7538 check_for_uninitialized_const_var (decl)
7539      tree decl;
7540 {
7541   tree type = TREE_TYPE (decl);
7542
7543   /* ``Unless explicitly declared extern, a const object does not have
7544      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7545      7.1.6 */
7546   if (TREE_CODE (decl) == VAR_DECL
7547       && TREE_CODE (type) != REFERENCE_TYPE
7548       && CP_TYPE_CONST_P (type)
7549       && !TYPE_NEEDS_CONSTRUCTING (type)
7550       && !DECL_INITIAL (decl))
7551     cp_error ("uninitialized const `%D'", decl);
7552 }
7553
7554 /* Verify INIT (the initializer for DECL), and record the
7555    initialization in DECL_INITIAL, if appropriate.  Returns a new
7556    value for INIT.  */
7557
7558 static tree
7559 check_initializer (decl, init)
7560      tree decl;
7561      tree init;
7562 {
7563   tree type;
7564
7565   if (TREE_CODE (decl) == FIELD_DECL)
7566     return init;
7567
7568   type = TREE_TYPE (decl);
7569
7570   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7571   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7572     init = NULL_TREE;
7573
7574   /* Check the initializer.  */
7575   if (init)
7576     {
7577       /* Things that are going to be initialized need to have complete
7578          type.  */
7579       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7580
7581       if (type == error_mark_node)
7582         /* We will have already complained.  */
7583         init = NULL_TREE;
7584       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7585         {
7586           cp_error ("variable-sized object `%D' may not be initialized", decl);
7587           init = NULL_TREE;
7588         }
7589       else if (TREE_CODE (type) == ARRAY_TYPE
7590                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7591         {
7592           cp_error ("elements of array `%#D' have incomplete type", decl);
7593           init = NULL_TREE;
7594         }
7595       else if (!COMPLETE_TYPE_P (type))
7596         {
7597           cp_error ("`%D' has incomplete type", decl);
7598           TREE_TYPE (decl) = error_mark_node;
7599           init = NULL_TREE;
7600         }
7601     }
7602
7603   if (TREE_CODE (decl) == CONST_DECL)
7604     {
7605       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7606
7607       DECL_INITIAL (decl) = init;
7608
7609       /* This will keep us from needing to worry about our obstacks.  */
7610       my_friendly_assert (init != NULL_TREE, 149);
7611       init = NULL_TREE;
7612     }
7613   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7614     {
7615       if (TREE_STATIC (decl))
7616         make_decl_rtl (decl, NULL_PTR);
7617       grok_reference_init (decl, type, init);
7618       init = NULL_TREE;
7619     }
7620   else if (init)
7621     {
7622       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7623         {
7624           if (TREE_CODE (type) == ARRAY_TYPE)
7625             init = digest_init (type, init, (tree *) 0);
7626           else if (TREE_CODE (init) == CONSTRUCTOR
7627                    && TREE_HAS_CONSTRUCTOR (init))
7628             {
7629               if (TYPE_NON_AGGREGATE_CLASS (type))
7630                 {
7631                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7632                             decl);
7633                   init = error_mark_node;
7634                 }
7635               else
7636                 goto dont_use_constructor;
7637             }
7638         }
7639       else
7640         {
7641         dont_use_constructor:
7642           if (TREE_CODE (init) != TREE_VEC)
7643             init = store_init_value (decl, init);
7644         }
7645
7646       if (init)
7647         /* We must hide the initializer so that expand_decl
7648            won't try to do something it does not understand.  */
7649         init = obscure_complex_init (decl, init);
7650     }
7651   else if (DECL_EXTERNAL (decl))
7652     ;
7653   else if (TYPE_P (type)
7654            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7655     {
7656       tree core_type = strip_array_types (type);
7657
7658       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7659         {
7660           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7661             cp_error ("structure `%D' with uninitialized const members", decl);
7662           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7663             cp_error ("structure `%D' with uninitialized reference members",
7664                       decl);
7665         }
7666
7667       check_for_uninitialized_const_var (decl);
7668
7669       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7670         init = obscure_complex_init (decl, NULL_TREE);
7671
7672     }
7673   else
7674     check_for_uninitialized_const_var (decl);
7675
7676   return init;
7677 }
7678
7679 /* If DECL is not a local variable, give it RTL.  */
7680
7681 static void
7682 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7683      tree decl;
7684      tree init;
7685      const char *asmspec;
7686 {
7687   int toplev = toplevel_bindings_p ();
7688   int defer_p;
7689
7690   /* Handle non-variables up front.  */
7691   if (TREE_CODE (decl) != VAR_DECL)
7692     {
7693       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7694       return;
7695     }
7696
7697   /* If we see a class member here, it should be a static data
7698      member.  */
7699   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7700     {
7701       my_friendly_assert (TREE_STATIC (decl), 19990828);
7702       /* An in-class declaration of a static data member should be
7703          external; it is only a declaration, and not a definition.  */
7704       if (init == NULL_TREE)
7705         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7706     }
7707
7708   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7709   if (asmspec)
7710     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7711
7712   /* We don't create any RTL for local variables.  */
7713   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7714     return;
7715
7716   /* We defer emission of local statics until the corresponding
7717      DECL_STMT is expanded.  */
7718   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7719
7720   /* We try to defer namespace-scope static constants so that they are
7721      not emitted into the object file unncessarily.  */
7722   if (!DECL_VIRTUAL_P (decl)
7723       && TREE_READONLY (decl)
7724       && DECL_INITIAL (decl) != NULL_TREE
7725       && DECL_INITIAL (decl) != error_mark_node
7726       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7727       && toplev
7728       && !TREE_PUBLIC (decl))
7729     {
7730       /* Fool with the linkage according to #pragma interface.  */
7731       if (!interface_unknown)
7732         {
7733           TREE_PUBLIC (decl) = 1;
7734           DECL_EXTERNAL (decl) = interface_only;
7735         }
7736
7737       defer_p = 1;
7738     }
7739
7740   /* If we're deferring the variable, just make RTL.  Do not actually
7741      emit the variable.  */
7742   if (defer_p)
7743     make_decl_rtl (decl, asmspec);
7744   /* If we're not deferring, go ahead and assemble the variable.  */
7745   else
7746     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7747 }
7748
7749 /* The old ARM scoping rules injected variables declared in the
7750    initialization statement of a for-statement into the surrounding
7751    scope.  We support this usage, in order to be backward-compatible.
7752    DECL is a just-declared VAR_DECL; if necessary inject its
7753    declaration into the surrounding scope.  */
7754
7755 void
7756 maybe_inject_for_scope_var (decl)
7757      tree decl;
7758 {
7759   if (!DECL_NAME (decl))
7760     return;
7761
7762   if (current_binding_level->is_for_scope)
7763     {
7764       struct binding_level *outer
7765         = current_binding_level->level_chain;
7766
7767       /* Check to see if the same name is already bound at the outer
7768          level, either because it was directly declared, or because a
7769          dead for-decl got preserved.  In either case, the code would
7770          not have been valid under the ARM scope rules, so clear
7771          is_for_scope for the current_binding_level.
7772
7773          Otherwise, we need to preserve the temp slot for decl to last
7774          into the outer binding level.  */
7775
7776       tree outer_binding
7777         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7778
7779       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7780           && (TREE_CODE (BINDING_VALUE (outer_binding))
7781               == VAR_DECL)
7782           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7783         {
7784           BINDING_VALUE (outer_binding)
7785             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7786           current_binding_level->is_for_scope = 0;
7787         }
7788       else if (DECL_IN_MEMORY_P (decl))
7789         preserve_temp_slots (DECL_RTL (decl));
7790     }
7791 }
7792
7793 /* Generate code to initialize DECL (a local variable).  */
7794
7795 void
7796 initialize_local_var (decl, init, flags)
7797      tree decl;
7798      tree init;
7799      int flags;
7800 {
7801   tree type = TREE_TYPE (decl);
7802
7803   /* If the type is bogus, don't bother initializing the variable.  */
7804   if (type == error_mark_node)
7805     return;
7806
7807   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7808     {
7809       /* If we used it already as memory, it must stay in memory.  */
7810       DECL_INITIAL (decl) = NULL_TREE;
7811       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7812     }
7813
7814   /* Local statics are handled differently from ordinary automatic
7815      variables.  */
7816   if (TREE_STATIC (decl))
7817     {
7818       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7819           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7820         expand_static_init (decl, init);
7821       return;
7822     }
7823
7824   if (DECL_SIZE (decl) && type != error_mark_node)
7825     {
7826       int already_used;
7827
7828       /* Compute and store the initial value.  */
7829       already_used = TREE_USED (decl) || TREE_USED (type);
7830
7831       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7832         {
7833           int saved_stmts_are_full_exprs_p;
7834
7835           my_friendly_assert (building_stmt_tree (), 20000906);
7836           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7837           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7838           finish_expr_stmt (build_aggr_init (decl, init, flags));
7839           current_stmt_tree ()->stmts_are_full_exprs_p =
7840             saved_stmts_are_full_exprs_p;
7841         }
7842
7843       /* Set this to 0 so we can tell whether an aggregate which was
7844          initialized was ever used.  Don't do this if it has a
7845          destructor, so we don't complain about the 'resource
7846          allocation is initialization' idiom.  Now set
7847          attribute((unused)) on types so decls of that type will be
7848          marked used. (see TREE_USED, above.)  */
7849       if (TYPE_NEEDS_CONSTRUCTING (type)
7850           && ! already_used
7851           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7852           && DECL_NAME (decl))
7853         TREE_USED (decl) = 0;
7854       else if (already_used)
7855         TREE_USED (decl) = 1;
7856     }
7857 }
7858
7859 /* Generate code to destroy DECL (a local variable).  */
7860
7861 static void
7862 destroy_local_var (decl)
7863      tree decl;
7864 {
7865   tree type = TREE_TYPE (decl);
7866   tree cleanup;
7867
7868   /* Only variables get cleaned up.  */
7869   if (TREE_CODE (decl) != VAR_DECL)
7870     return;
7871
7872   /* And only things with destructors need cleaning up.  */
7873   if (type == error_mark_node
7874       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7875     return;
7876
7877   if (TREE_CODE (decl) == VAR_DECL &&
7878       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7879     /* We don't clean up things that aren't defined in this
7880        translation unit, or that need a static cleanup.  The latter
7881        are handled by finish_file.  */
7882     return;
7883
7884   /* Compute the cleanup.  */
7885   cleanup = maybe_build_cleanup (decl);
7886
7887   /* Record the cleanup required for this declaration.  */
7888   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7889       && cleanup)
7890     finish_decl_cleanup (decl, cleanup);
7891 }
7892
7893 /* Finish processing of a declaration;
7894    install its line number and initial value.
7895    If the length of an array type is not known before,
7896    it must be determined now, from the initial value, or it is an error.
7897
7898    INIT holds the value of an initializer that should be allowed to escape
7899    the normal rules.
7900
7901    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7902    if the (init) syntax was used.  */
7903
7904 void
7905 cp_finish_decl (decl, init, asmspec_tree, flags)
7906      tree decl, init;
7907      tree asmspec_tree;
7908      int flags;
7909 {
7910   register tree type;
7911   tree ttype = NULL_TREE;
7912   const char *asmspec = NULL;
7913   int was_readonly = 0;
7914
7915   if (! decl)
7916     {
7917       if (init)
7918         error ("assignment (not initialization) in declaration");
7919       return;
7920     }
7921
7922   /* If a name was specified, get the string.  */
7923   if (asmspec_tree)
7924       asmspec = TREE_STRING_POINTER (asmspec_tree);
7925
7926   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7927     {
7928       cp_error ("cannot initialize `%D' to namespace `%D'",
7929                 decl, init);
7930       init = NULL_TREE;
7931     }
7932
7933   if (current_class_type
7934       && CP_DECL_CONTEXT (decl) == current_class_type
7935       && TYPE_BEING_DEFINED (current_class_type)
7936       && (DECL_INITIAL (decl) || init))
7937     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
7938
7939   if (TREE_CODE (decl) == VAR_DECL
7940       && DECL_CONTEXT (decl)
7941       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7942       && DECL_CONTEXT (decl) != current_namespace
7943       && init)
7944     {
7945       /* Leave the namespace of the object. */
7946       pop_decl_namespace ();
7947     }
7948
7949   type = TREE_TYPE (decl);
7950
7951   if (type == error_mark_node)
7952     return;
7953
7954   /* Add this declaration to the statement-tree.  */
7955   if (building_stmt_tree ()
7956       && at_function_scope_p ()
7957       && TREE_CODE (decl) != RESULT_DECL)
7958     add_decl_stmt (decl);
7959
7960   if (TYPE_HAS_MUTABLE_P (type))
7961     TREE_READONLY (decl) = 0;
7962
7963   if (processing_template_decl)
7964     {
7965       if (init && DECL_INITIAL (decl))
7966         DECL_INITIAL (decl) = init;
7967       goto finish_end0;
7968     }
7969
7970   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7971   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7972
7973   /* Take care of TYPE_DECLs up front.  */
7974   if (TREE_CODE (decl) == TYPE_DECL)
7975     {
7976       if (init && DECL_INITIAL (decl))
7977         {
7978           /* typedef foo = bar; store the type of bar as the type of foo.  */
7979           TREE_TYPE (decl) = type = TREE_TYPE (init);
7980           DECL_INITIAL (decl) = init = NULL_TREE;
7981         }
7982       if (type != error_mark_node
7983           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7984         {
7985           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7986             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7987           set_identifier_type_value (DECL_NAME (decl), type);
7988           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7989         }
7990       GNU_xref_decl (current_function_decl, decl);
7991
7992       /* If we have installed this as the canonical typedef for this
7993          type, and that type has not been defined yet, delay emitting
7994          the debug information for it, as we will emit it later.  */
7995       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7996           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
7997         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7998
7999       rest_of_decl_compilation (decl, NULL_PTR,
8000                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8001       goto finish_end;
8002     }
8003
8004   if (TREE_CODE (decl) != FUNCTION_DECL)
8005     ttype = target_type (type);
8006
8007   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8008       && TYPE_NEEDS_CONSTRUCTING (type))
8009     {
8010       /* Currently, GNU C++ puts constants in text space, making them
8011          impossible to initialize.  In the future, one would hope for
8012          an operating system which understood the difference between
8013          initialization and the running of a program.  */
8014       was_readonly = 1;
8015       TREE_READONLY (decl) = 0;
8016     }
8017
8018   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8019     {
8020       /* This must override the asm specifier which was placed by
8021          grokclassfn.  Lay this out fresh.  */
8022       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8023       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8024       make_decl_rtl (decl, asmspec);
8025     }
8026
8027   /* Deduce size of array from initialization, if not already known.  */
8028   maybe_deduce_size_from_array_init (decl, init);
8029   init = check_initializer (decl, init);
8030
8031   GNU_xref_decl (current_function_decl, decl);
8032
8033   if (TREE_CODE (decl) == VAR_DECL)
8034     layout_var_decl (decl);
8035
8036   /* Output the assembler code and/or RTL code for variables and functions,
8037      unless the type is an undefined structure or union.
8038      If not, it will get done when the type is completed.  */
8039   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8040       || TREE_CODE (decl) == RESULT_DECL)
8041     {
8042       if (TREE_CODE (decl) == VAR_DECL)
8043         maybe_commonize_var (decl);
8044
8045       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8046
8047       if (TREE_CODE (type) == FUNCTION_TYPE
8048           || TREE_CODE (type) == METHOD_TYPE)
8049         abstract_virtuals_error (decl,
8050                                  strip_array_types (TREE_TYPE (type)));
8051       else
8052         abstract_virtuals_error (decl, strip_array_types (type));
8053
8054       if (TREE_CODE (decl) == FUNCTION_DECL)
8055         ;
8056       else if (DECL_EXTERNAL (decl)
8057                && ! (DECL_LANG_SPECIFIC (decl)
8058                      && DECL_NOT_REALLY_EXTERN (decl)))
8059         {
8060           if (init)
8061             DECL_INITIAL (decl) = init;
8062         }
8063       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8064         {
8065           /* This is a local declaration.  */
8066           if (doing_semantic_analysis_p ())
8067             maybe_inject_for_scope_var (decl);
8068           /* Initialize the local variable.  But, if we're building a
8069              statement-tree, we'll do the initialization when we
8070              expand the tree.  */
8071           if (processing_template_decl)
8072             {
8073               if (init || DECL_INITIAL (decl) == error_mark_node)
8074                 DECL_INITIAL (decl) = init;
8075             }
8076           else
8077             {
8078               /* If we're not building RTL, then we need to do so
8079                  now.  */
8080               my_friendly_assert (building_stmt_tree (), 20000906);
8081               /* Initialize the variable.  */
8082               initialize_local_var (decl, init, flags);
8083               /* Clean up the variable.  */
8084               destroy_local_var (decl);
8085             }
8086         }
8087       else if (TREE_STATIC (decl) && type != error_mark_node)
8088         {
8089           /* Cleanups for static variables are handled by `finish_file'.  */
8090           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8091               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8092             expand_static_init (decl, init);
8093         }
8094     finish_end0:
8095
8096       /* Undo call to `pushclass' that was done in `start_decl'
8097          due to initialization of qualified member variable.
8098          I.e., Foo::x = 10;  */
8099       {
8100         tree context = CP_DECL_CONTEXT (decl);
8101         if (context
8102             && TYPE_P (context)
8103             && (TREE_CODE (decl) == VAR_DECL
8104                 /* We also have a pushclass done that we need to undo here
8105                    if we're at top level and declare a method.  */
8106                 || TREE_CODE (decl) == FUNCTION_DECL)
8107             /* If size hasn't been set, we're still defining it,
8108                and therefore inside the class body; don't pop
8109                the binding level..  */
8110             && COMPLETE_TYPE_P (context)
8111             && context == current_class_type)
8112           pop_nested_class ();
8113       }
8114     }
8115
8116  finish_end:
8117
8118   if (was_readonly)
8119     TREE_READONLY (decl) = 1;
8120 }
8121
8122 /* This is here for a midend callback from c-common.c */
8123
8124 void
8125 finish_decl (decl, init, asmspec_tree)
8126      tree decl, init;
8127      tree asmspec_tree;
8128 {
8129   cp_finish_decl (decl, init, asmspec_tree, 0);
8130 }
8131
8132 /* Returns a declaration for a VAR_DECL as if:
8133
8134      extern "C" TYPE NAME;
8135
8136    had been seen.  Used to create compiler-generated global
8137    variables.  */
8138
8139 tree
8140 declare_global_var (name, type)
8141      tree name;
8142      tree type;
8143 {
8144   tree decl;
8145
8146   push_to_top_level ();
8147   decl = build_decl (VAR_DECL, name, type);
8148   TREE_PUBLIC (decl) = 1;
8149   DECL_EXTERNAL (decl) = 1;
8150   DECL_ARTIFICIAL (decl) = 1;
8151   pushdecl (decl);
8152   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8153   pop_from_top_level ();
8154
8155   return decl;
8156 }
8157
8158 /* Returns a pointer to the `atexit' function.  Note that if
8159    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8160    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8161
8162 static tree
8163 get_atexit_node ()
8164 {
8165   tree atexit_fndecl;
8166   tree arg_types;
8167   tree fn_type;
8168   tree fn_ptr_type;
8169   const char *name;
8170
8171   if (atexit_node)
8172     return atexit_node;
8173
8174   if (flag_use_cxa_atexit)
8175     {
8176       /* The declaration for `__cxa_atexit' is:
8177
8178            int __cxa_atexit (void (*)(void *), void *, void *)
8179
8180          We build up the argument types and then then function type
8181          itself.  */
8182
8183       /* First, build the pointer-to-function type for the first
8184          argument.  */
8185       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8186       fn_type = build_function_type (void_type_node, arg_types);
8187       fn_ptr_type = build_pointer_type (fn_type);
8188       /* Then, build the rest of the argument types.  */
8189       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8190       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8191       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8192       /* And the final __cxa_atexit type.  */
8193       fn_type = build_function_type (integer_type_node, arg_types);
8194       fn_ptr_type = build_pointer_type (fn_type);
8195       name = "__cxa_atexit";
8196     }
8197   else
8198     {
8199       /* The declaration for `atexit' is:
8200
8201            int atexit (void (*)());
8202
8203          We build up the argument types and then then function type
8204          itself.  */
8205       fn_type = build_function_type (void_type_node, void_list_node);
8206       fn_ptr_type = build_pointer_type (fn_type);
8207       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8208       /* Build the final atexit type.  */
8209       fn_type = build_function_type (integer_type_node, arg_types);
8210       name = "atexit";
8211     }
8212
8213   /* Now, build the function declaration.  */
8214   push_lang_context (lang_name_c);
8215   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8216   mark_used (atexit_fndecl);
8217   pop_lang_context ();
8218   atexit_node = default_conversion (atexit_fndecl);
8219
8220   return atexit_node;
8221 }
8222
8223 /* Returns the __dso_handle VAR_DECL.  */
8224
8225 static tree
8226 get_dso_handle_node ()
8227 {
8228   if (dso_handle_node)
8229     return dso_handle_node;
8230
8231   /* Declare the variable.  */
8232   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8233                                         ptr_type_node);
8234
8235   return dso_handle_node;
8236 }
8237
8238 /* Begin a new function with internal linkage whose job will be simply
8239    to destroy some particular variable.  */
8240
8241 static tree
8242 start_cleanup_fn ()
8243 {
8244   static int counter = 0;
8245   int old_interface_unknown = interface_unknown;
8246   char name[32];
8247   tree parmtypes;
8248   tree fntype;
8249   tree fndecl;
8250
8251   push_to_top_level ();
8252
8253   /* No need to mangle this.  */
8254   push_lang_context (lang_name_c);
8255
8256   interface_unknown = 1;
8257
8258   /* Build the parameter-types.  */
8259   parmtypes = void_list_node;
8260   /* Functions passed to __cxa_atexit take an additional parameter.
8261      We'll just ignore it.  After we implement the new calling
8262      convention for destructors, we can eliminate the use of
8263      additional cleanup functions entirely in the -fnew-abi case.  */
8264   if (flag_use_cxa_atexit)
8265     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8266   /* Build the function type itself.  */
8267   fntype = build_function_type (void_type_node, parmtypes);
8268   /* Build the name of the function.  */
8269   sprintf (name, "__tcf_%d", counter++);
8270   /* Build the function declaration.  */
8271   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8272   /* It's a function with internal linkage, generated by the
8273      compiler.  */
8274   TREE_PUBLIC (fndecl) = 0;
8275   DECL_ARTIFICIAL (fndecl) = 1;
8276   /* Make the function `inline' so that it is only emitted if it is
8277      actually needed.  It is unlikely that it will be inlined, since
8278      it is only called via a function pointer, but we avoid unncessary
8279      emissions this way.  */
8280   DECL_INLINE (fndecl) = 1;
8281   /* Build the parameter.  */
8282   if (flag_use_cxa_atexit)
8283     {
8284       tree parmdecl;
8285
8286       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8287       DECL_CONTEXT (parmdecl) = fndecl;
8288       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8289       TREE_USED (parmdecl) = 1;
8290       DECL_ARGUMENTS (fndecl) = parmdecl;
8291     }
8292
8293   pushdecl (fndecl);
8294   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8295   do_pushlevel ();
8296
8297   interface_unknown = old_interface_unknown;
8298
8299   pop_lang_context ();
8300
8301   return current_function_decl;
8302 }
8303
8304 /* Finish the cleanup function begun by start_cleanup_fn.  */
8305
8306 static void
8307 end_cleanup_fn ()
8308 {
8309   do_poplevel ();
8310
8311   expand_body (finish_function (0));
8312
8313   pop_from_top_level ();
8314 }
8315
8316 /* Generate code to handle the destruction of DECL, an object with
8317    static storage duration.  */
8318
8319 void
8320 register_dtor_fn (decl)
8321      tree decl;
8322 {
8323   tree cleanup;
8324   tree compound_stmt;
8325   tree args;
8326   tree fcall;
8327
8328   int saved_flag_access_control;
8329
8330   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8331     return;
8332
8333   /* Call build_cleanup before we enter the anonymous function so that
8334      any access checks will be done relative to the current scope,
8335      rather than the scope of the anonymous function.  */
8336   build_cleanup (decl);
8337
8338   /* Now start the function.  */
8339   cleanup = start_cleanup_fn ();
8340
8341   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8342      to the original function, rather than the anonymous one.  That
8343      will make the back-end think that nested functions are in use,
8344      which causes confusion.  */
8345   saved_flag_access_control = flag_access_control;
8346   flag_access_control = 0;
8347   fcall = build_cleanup (decl);
8348   flag_access_control = saved_flag_access_control;
8349
8350   /* Create the body of the anonymous function.  */
8351   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8352   finish_expr_stmt (fcall);
8353   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8354   end_cleanup_fn ();
8355
8356   /* Call atexit with the cleanup function.  */
8357   mark_addressable (cleanup);
8358   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8359   if (flag_use_cxa_atexit)
8360     {
8361       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8362       args = tree_cons (NULL_TREE, null_pointer_node, args);
8363       args = tree_cons (NULL_TREE, cleanup, args);
8364     }
8365   else
8366     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8367   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8368 }
8369
8370 void
8371 expand_static_init (decl, init)
8372      tree decl;
8373      tree init;
8374 {
8375   tree oldstatic = value_member (decl, static_aggregates);
8376
8377   if (oldstatic)
8378     {
8379       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8380         cp_error ("multiple initializations given for `%D'", decl);
8381     }
8382   else if (! toplevel_bindings_p ())
8383     {
8384       /* Emit code to perform this initialization but once.  */
8385       tree if_stmt;
8386       tree then_clause;
8387       tree assignment;
8388       tree guard;
8389       tree guard_init;
8390
8391       /* Emit code to perform this initialization but once.  This code
8392          looks like:
8393
8394            static int guard = 0;
8395            if (!guard) {
8396              // Do initialization.
8397              guard = 1;
8398              // Register variable for destruction at end of program.
8399            }
8400
8401          Note that the `temp' variable is only set to 1 *after* the
8402          initialization is complete.  This ensures that an exception,
8403          thrown during the construction, will cause the variable to
8404          reinitialized when we pass through this code again, as per:
8405
8406            [stmt.dcl]
8407
8408            If the initialization exits by throwing an exception, the
8409            initialization is not complete, so it will be tried again
8410            the next time control enters the declaration.
8411
8412          In theory, this process should be thread-safe, too; multiple
8413          threads should not be able to initialize the variable more
8414          than once.  We don't yet attempt to ensure thread-safety.  */
8415
8416       /* Create the guard variable.  */
8417       guard = get_guard (decl);
8418
8419       /* Begin the conditional initialization.  */
8420       if_stmt = begin_if_stmt ();
8421       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8422       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8423
8424       /* Do the initialization itself.  */
8425       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8426           || (init && TREE_CODE (init) == TREE_LIST))
8427         assignment = build_aggr_init (decl, init, 0);
8428       else if (init)
8429         /* The initialization we're doing here is just a bitwise
8430            copy.  */
8431         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8432       else
8433         assignment = NULL_TREE;
8434
8435       /* Once the assignment is complete, set TEMP to 1.  Since the
8436          construction of the static object is complete at this point,
8437          we want to make sure TEMP is set to 1 even if a temporary
8438          constructed during the initialization throws an exception
8439          when it is destroyed.  So, we combine the initialization and
8440          the assignment to TEMP into a single expression, ensuring
8441          that when we call finish_expr_stmt the cleanups will not be
8442          run until after TEMP is set to 1.  */
8443       guard_init = set_guard (guard);
8444       if (assignment)
8445         {
8446           assignment = tree_cons (NULL_TREE, assignment,
8447                                   build_tree_list (NULL_TREE,
8448                                                    guard_init));
8449           assignment = build_compound_expr (assignment);
8450         }
8451       else
8452         assignment = guard_init;
8453       finish_expr_stmt (assignment);
8454
8455       /* Use atexit to register a function for destroying this static
8456          variable.  */
8457       register_dtor_fn (decl);
8458
8459       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8460       finish_then_clause (if_stmt);
8461       finish_if_stmt ();
8462     }
8463   else
8464     static_aggregates = tree_cons (init, decl, static_aggregates);
8465 }
8466
8467 /* Finish the declaration of a catch-parameter.  */
8468
8469 tree
8470 start_handler_parms (declspecs, declarator)
8471      tree declspecs;
8472      tree declarator;
8473 {
8474   tree decl;
8475   if (declspecs)
8476     {
8477       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8478                              1, NULL_TREE);
8479       if (decl == NULL_TREE)
8480         error ("invalid catch parameter");
8481     }
8482   else
8483     decl = NULL_TREE;
8484
8485   return decl;
8486 }
8487
8488 \f
8489 /* Make TYPE a complete type based on INITIAL_VALUE.
8490    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8491    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8492
8493 int
8494 complete_array_type (type, initial_value, do_default)
8495      tree type, initial_value;
8496      int do_default;
8497 {
8498   register tree maxindex = NULL_TREE;
8499   int value = 0;
8500
8501   if (initial_value)
8502     {
8503       /* An array of character type can be initialized from a
8504          brace-enclosed string constant.  */
8505       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8506           && TREE_CODE (initial_value) == CONSTRUCTOR
8507           && CONSTRUCTOR_ELTS (initial_value)
8508           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8509               == STRING_CST)
8510           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8511         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8512
8513       /* Note MAXINDEX is really the maximum index, one less than the
8514          size.  */
8515       if (TREE_CODE (initial_value) == STRING_CST)
8516         {
8517           int eltsize
8518             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8519           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8520                                    / eltsize) - 1, 0);
8521         }
8522       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8523         {
8524           tree elts = CONSTRUCTOR_ELTS (initial_value);
8525
8526           maxindex = ssize_int (-1);
8527           for (; elts; elts = TREE_CHAIN (elts))
8528             {
8529               if (TREE_PURPOSE (elts))
8530                 maxindex = TREE_PURPOSE (elts);
8531               else
8532                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8533             }
8534           maxindex = copy_node (maxindex);
8535         }
8536       else
8537         {
8538           /* Make an error message unless that happened already.  */
8539           if (initial_value != error_mark_node)
8540             value = 1;
8541           else
8542             initial_value = NULL_TREE;
8543
8544           /* Prevent further error messages.  */
8545           maxindex = build_int_2 (0, 0);
8546         }
8547     }
8548
8549   if (!maxindex)
8550     {
8551       if (do_default)
8552         maxindex = build_int_2 (0, 0);
8553       value = 2;
8554     }
8555
8556   if (maxindex)
8557     {
8558       tree itype;
8559       tree domain;
8560
8561       domain = build_index_type (maxindex);
8562       TYPE_DOMAIN (type) = domain;
8563
8564       if (! TREE_TYPE (maxindex))
8565         TREE_TYPE (maxindex) = domain;
8566       if (initial_value)
8567         itype = TREE_TYPE (initial_value);
8568       else
8569         itype = NULL;
8570       if (itype && !TYPE_DOMAIN (itype))
8571         TYPE_DOMAIN (itype) = domain;
8572       /* The type of the main variant should never be used for arrays
8573          of different sizes.  It should only ever be completed with the
8574          size of the array.  */
8575       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8576         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8577     }
8578
8579   /* Lay out the type now that we can get the real answer.  */
8580
8581   layout_type (type);
8582
8583   return value;
8584 }
8585 \f
8586 /* Return zero if something is declared to be a member of type
8587    CTYPE when in the context of CUR_TYPE.  STRING is the error
8588    message to print in that case.  Otherwise, quietly return 1.  */
8589
8590 static int
8591 member_function_or_else (ctype, cur_type, flags)
8592      tree ctype, cur_type;
8593      enum overload_flags flags;
8594 {
8595   if (ctype && ctype != cur_type)
8596     {
8597       if (flags == DTOR_FLAG)
8598         cp_error ("destructor for alien class `%T' cannot be a member",
8599                   ctype);
8600       else
8601         cp_error ("constructor for alien class `%T' cannot be a member",
8602                   ctype);
8603       return 0;
8604     }
8605   return 1;
8606 }
8607 \f
8608 /* Subroutine of `grokdeclarator'.  */
8609
8610 /* Generate errors possibly applicable for a given set of specifiers.
8611    This is for ARM $7.1.2.  */
8612
8613 static void
8614 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8615      tree object;
8616      const char *type;
8617      int virtualp, quals, friendp, raises, inlinep;
8618 {
8619   if (virtualp)
8620     cp_error ("`%D' declared as a `virtual' %s", object, type);
8621   if (inlinep)
8622     cp_error ("`%D' declared as an `inline' %s", object, type);
8623   if (quals)
8624     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8625               object, type);
8626   if (friendp)
8627     cp_error_at ("`%D' declared as a friend", object);
8628   if (raises)
8629     cp_error_at ("`%D' declared with an exception specification", object);
8630 }
8631
8632 /* CTYPE is class type, or null if non-class.
8633    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8634    or METHOD_TYPE.
8635    DECLARATOR is the function's name.
8636    VIRTUALP is truthvalue of whether the function is virtual or not.
8637    FLAGS are to be passed through to `grokclassfn'.
8638    QUALS are qualifiers indicating whether the function is `const'
8639    or `volatile'.
8640    RAISES is a list of exceptions that this function can raise.
8641    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8642    not look, and -1 if we should not call `grokclassfn' at all.
8643
8644    Returns `NULL_TREE' if something goes wrong, after issuing
8645    applicable error messages.  */
8646
8647 static tree
8648 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8649             raises, check, friendp, publicp, inlinep, funcdef_flag,
8650             template_count, in_namespace)
8651      tree ctype, type;
8652      tree declarator;
8653      tree orig_declarator;
8654      int virtualp;
8655      enum overload_flags flags;
8656      tree quals, raises;
8657      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8658      tree in_namespace;
8659 {
8660   tree cname, decl;
8661   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8662   int has_default_arg = 0;
8663   tree t;
8664
8665   if (ctype)
8666     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8667       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8668   else
8669     cname = NULL_TREE;
8670
8671   if (raises)
8672     {
8673       type = build_exception_variant (type, raises);
8674     }
8675
8676   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8677   /* Propagate volatile out from type to decl. */
8678   if (TYPE_VOLATILE (type))
8679     TREE_THIS_VOLATILE (decl) = 1;
8680
8681   /* If this decl has namespace scope, set that up.  */
8682   if (in_namespace)
8683     set_decl_namespace (decl, in_namespace, friendp);
8684   else if (!ctype)
8685     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8686
8687   /* `main' and builtins have implicit 'C' linkage.  */
8688   if ((MAIN_NAME_P (declarator)
8689        || (IDENTIFIER_LENGTH (declarator) > 10
8690            && IDENTIFIER_POINTER (declarator)[0] == '_'
8691            && IDENTIFIER_POINTER (declarator)[1] == '_'
8692            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8693       && current_lang_name == lang_name_cplusplus
8694       && ctype == NULL_TREE
8695       /* NULL_TREE means global namespace.  */
8696       && DECL_CONTEXT (decl) == NULL_TREE)
8697     DECL_LANGUAGE (decl) = lang_c;
8698
8699   /* Should probably propagate const out from type to decl I bet (mrs).  */
8700   if (staticp)
8701     {
8702       DECL_STATIC_FUNCTION_P (decl) = 1;
8703       DECL_CONTEXT (decl) = ctype;
8704     }
8705
8706   if (ctype)
8707     DECL_CONTEXT (decl) = ctype;
8708
8709   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8710     {
8711       if (processing_template_decl)
8712         error ("cannot declare `::main' to be a template");
8713       if (inlinep)
8714         error ("cannot declare `::main' to be inline");
8715       if (!publicp)
8716         error ("cannot declare `::main' to be static");
8717       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8718                         integer_type_node))
8719         error ("`main' must return `int'");
8720       inlinep = 0;
8721       publicp = 1;
8722     }
8723
8724   /* Members of anonymous types and local classes have no linkage; make
8725      them internal.  */
8726   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8727                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8728     publicp = 0;
8729
8730   if (publicp)
8731     {
8732       /* [basic.link]: A name with no linkage (notably, the name of a class
8733          or enumeration declared in a local scope) shall not be used to
8734          declare an entity with linkage.
8735
8736          Only check this for public decls for now.  */
8737       t = no_linkage_check (TREE_TYPE (decl));
8738       if (t)
8739         {
8740           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8741             {
8742               if (DECL_EXTERN_C_P (decl))
8743                 /* Allow this; it's pretty common in C.  */;
8744               else
8745                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8746                             decl);
8747             }
8748           else
8749             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8750                         decl, t);
8751         }
8752     }
8753
8754   TREE_PUBLIC (decl) = publicp;
8755   if (! publicp)
8756     {
8757       DECL_INTERFACE_KNOWN (decl) = 1;
8758       DECL_NOT_REALLY_EXTERN (decl) = 1;
8759     }
8760
8761   if (inlinep)
8762     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8763
8764   DECL_EXTERNAL (decl) = 1;
8765   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8766     {
8767       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8768                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8769       quals = NULL_TREE;
8770     }
8771
8772   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8773     grok_op_properties (decl, virtualp, check < 0);
8774
8775   if (ctype && decl_function_context (decl))
8776     DECL_NO_STATIC_CHAIN (decl) = 1;
8777
8778   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8779     if (TREE_PURPOSE (t)
8780         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8781       {
8782         has_default_arg = 1;
8783         break;
8784       }
8785
8786   if (friendp
8787       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8788     {
8789       if (funcdef_flag)
8790         cp_error
8791           ("defining explicit specialization `%D' in friend declaration",
8792            orig_declarator);
8793       else
8794         {
8795           tree fns = TREE_OPERAND (orig_declarator, 0);
8796           tree args = TREE_OPERAND (orig_declarator, 1);
8797
8798           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8799             {
8800               /* Something like `template <class T> friend void f<T>()'.  */
8801               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8802                         orig_declarator);
8803               return NULL_TREE;
8804             }
8805
8806
8807           /* A friend declaration of the form friend void f<>().  Record
8808              the information in the TEMPLATE_ID_EXPR.  */
8809           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8810
8811           if (TREE_CODE (fns) == COMPONENT_REF)
8812             {
8813               /* Due to bison parser ickiness, we will have already looked
8814                  up an operator_name or PFUNCNAME within the current class
8815                  (see template_id in parse.y). If the current class contains
8816                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8817
8818               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8819                                   == current_class_type, 20001120);
8820               fns = TREE_OPERAND (fns, 1);
8821             }
8822           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8823                               || TREE_CODE (fns) == LOOKUP_EXPR
8824                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8825           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8826
8827           if (has_default_arg)
8828             {
8829               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8830                         decl);
8831               return NULL_TREE;
8832             }
8833
8834           if (inlinep)
8835             {
8836               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8837                         decl);
8838               return NULL_TREE;
8839             }
8840         }
8841     }
8842
8843   if (has_default_arg)
8844     add_defarg_fn (decl);
8845
8846   /* Plain overloading: will not be grok'd by grokclassfn.  */
8847   if (! ctype && ! processing_template_decl
8848       && (! DECL_EXTERN_C_P (decl) || DECL_OVERLOADED_OPERATOR_P (decl))
8849       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8850     set_mangled_name_for_decl (decl);
8851
8852   if (funcdef_flag)
8853     /* Make the init_value nonzero so pushdecl knows this is not
8854        tentative.  error_mark_node is replaced later with the BLOCK.  */
8855     DECL_INITIAL (decl) = error_mark_node;
8856
8857   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8858     TREE_NOTHROW (decl) = 1;
8859
8860   /* Caller will do the rest of this.  */
8861   if (check < 0)
8862     return decl;
8863
8864   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8865     DECL_CONSTRUCTOR_P (decl) = 1;
8866
8867   /* Function gets the ugly name, field gets the nice one.  This call
8868      may change the type of the function (because of default
8869      parameters)!  */
8870   if (ctype != NULL_TREE)
8871     grokclassfn (ctype, decl, flags, quals);
8872
8873   decl = check_explicit_specialization (orig_declarator, decl,
8874                                         template_count,
8875                                         2 * (funcdef_flag != 0) +
8876                                         4 * (friendp != 0));
8877   if (decl == error_mark_node)
8878     return NULL_TREE;
8879
8880   if (ctype != NULL_TREE
8881       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8882       && check)
8883     {
8884       tree old_decl;
8885
8886       old_decl = check_classfn (ctype, decl);
8887
8888       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8889         /* Because grokfndecl is always supposed to return a
8890            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8891            here.  We depend on our callers to figure out that its
8892            really a template that's being returned.  */
8893         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8894
8895       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8896           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8897         {
8898           /* Remove the `this' parm added by grokclassfn.
8899              XXX Isn't this done in start_function, too?  */
8900           revert_static_member_fn (decl);
8901           last_function_parms = TREE_CHAIN (last_function_parms);
8902         }
8903       if (old_decl && DECL_ARTIFICIAL (old_decl))
8904         cp_error ("definition of implicitly-declared `%D'", old_decl);
8905
8906       if (old_decl)
8907         {
8908           /* Since we've smashed OLD_DECL to its
8909              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8910           if (TREE_CODE (decl) == TEMPLATE_DECL)
8911             decl = DECL_TEMPLATE_RESULT (decl);
8912
8913           /* Attempt to merge the declarations.  This can fail, in
8914              the case of some illegal specialization declarations.  */
8915           if (!duplicate_decls (decl, old_decl))
8916             cp_error ("no `%#D' member function declared in class `%T'",
8917                       decl, ctype);
8918           return old_decl;
8919         }
8920     }
8921
8922   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8923     return NULL_TREE;
8924
8925   if (ctype == NULL_TREE || check)
8926     return decl;
8927
8928   if (virtualp)
8929     DECL_VIRTUAL_P (decl) = 1;
8930
8931   return decl;
8932 }
8933
8934 static tree
8935 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8936      tree type;
8937      tree declarator;
8938      RID_BIT_TYPE *specbits_in;
8939      int initialized;
8940      int constp;
8941      tree in_namespace;
8942 {
8943   tree decl;
8944   RID_BIT_TYPE specbits;
8945
8946   specbits = *specbits_in;
8947
8948   if (TREE_CODE (type) == OFFSET_TYPE)
8949     {
8950       /* If you declare a static member so that it
8951          can be initialized, the code will reach here.  */
8952       tree basetype = TYPE_OFFSET_BASETYPE (type);
8953       type = TREE_TYPE (type);
8954       decl = build_lang_decl (VAR_DECL, declarator, type);
8955       DECL_CONTEXT (decl) = basetype;
8956       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
8957          templates.  */
8958       if (!uses_template_parms (decl))
8959         {
8960           if (flag_new_abi)
8961             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
8962           else
8963             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
8964                                                             declarator);
8965         }
8966     }
8967   else
8968     {
8969       tree context;
8970
8971       if (in_namespace)
8972         context = in_namespace;
8973       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8974         context = current_namespace;
8975       else
8976         context = NULL_TREE;
8977
8978       if (processing_template_decl && context)
8979         /* For global variables, declared in a template, we need the
8980            full lang_decl.  */
8981         decl = build_lang_decl (VAR_DECL, declarator, type);
8982       else
8983         decl = build_decl (VAR_DECL, declarator, type);
8984
8985       if (context)
8986         set_decl_namespace (decl, context, 0);
8987
8988       context = DECL_CONTEXT (decl);
8989       if (declarator && context && current_lang_name != lang_name_c)
8990         {
8991           if (flag_new_abi)
8992             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
8993           else
8994             DECL_ASSEMBLER_NAME (decl)
8995               = build_static_name (context, declarator);
8996         }
8997     }
8998
8999   if (in_namespace)
9000     set_decl_namespace (decl, in_namespace, 0);
9001
9002   if (RIDBIT_SETP (RID_EXTERN, specbits))
9003     {
9004       DECL_THIS_EXTERN (decl) = 1;
9005       DECL_EXTERNAL (decl) = !initialized;
9006     }
9007
9008   /* In class context, static means one per class,
9009      public access, and static storage.  */
9010   if (DECL_CLASS_SCOPE_P (decl))
9011     {
9012       TREE_PUBLIC (decl) = 1;
9013       TREE_STATIC (decl) = 1;
9014       DECL_EXTERNAL (decl) = 0;
9015     }
9016   /* At top level, either `static' or no s.c. makes a definition
9017      (perhaps tentative), and absence of `static' makes it public.  */
9018   else if (toplevel_bindings_p ())
9019     {
9020       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9021                             && (DECL_THIS_EXTERN (decl) || ! constp));
9022       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9023     }
9024   /* Not at top level, only `static' makes a static definition.  */
9025   else
9026     {
9027       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9028       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9029     }
9030
9031   if (TREE_PUBLIC (decl))
9032     {
9033       /* [basic.link]: A name with no linkage (notably, the name of a class
9034          or enumeration declared in a local scope) shall not be used to
9035          declare an entity with linkage.
9036
9037          Only check this for public decls for now.  */
9038       tree t = no_linkage_check (TREE_TYPE (decl));
9039       if (t)
9040         {
9041           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9042             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9043           else
9044             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9045                         decl, t);
9046         }
9047     }
9048
9049   return decl;
9050 }
9051
9052 /* Create and return a canonical pointer to member function type, for
9053    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9054
9055 tree
9056 build_ptrmemfunc_type (type)
9057      tree type;
9058 {
9059   tree fields[4];
9060   tree t;
9061   tree u;
9062   tree unqualified_variant = NULL_TREE;
9063
9064   if (type == error_mark_node)
9065     return type;
9066
9067   /* If a canonical type already exists for this type, use it.  We use
9068      this method instead of type_hash_canon, because it only does a
9069      simple equality check on the list of field members.  */
9070
9071   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9072     return t;
9073
9074   /* Make sure that we always have the unqualified pointer-to-member
9075      type first.  */
9076   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9077     unqualified_variant
9078       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9079
9080   t = make_aggr_type (RECORD_TYPE);
9081   /* Let the front-end know this is a pointer to member function...  */
9082   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9083   /* ... and not really an aggregate.  */
9084   SET_IS_AGGR_TYPE (t, 0);
9085
9086   if (!flag_new_abi)
9087     {
9088       u = make_aggr_type (UNION_TYPE);
9089       SET_IS_AGGR_TYPE (u, 0);
9090       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9091       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9092                               delta_type_node);
9093       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9094       TYPE_NAME (u) = NULL_TREE;
9095
9096       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9097                               delta_type_node);
9098       fields[1] = build_decl (FIELD_DECL, index_identifier,
9099                               delta_type_node);
9100       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9101       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9102     }
9103   else
9104     {
9105       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9106       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9107                               delta_type_node);
9108       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9109     }
9110
9111   /* Zap out the name so that the back-end will give us the debugging
9112      information for this anonymous RECORD_TYPE.  */
9113   TYPE_NAME (t) = NULL_TREE;
9114
9115   /* If this is not the unqualified form of this pointer-to-member
9116      type, set the TYPE_MAIN_VARIANT for this type to be the
9117      unqualified type.  Since they are actually RECORD_TYPEs that are
9118      not variants of each other, we must do this manually.  */
9119   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9120     {
9121       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9122       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9123       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9124       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9125     }
9126
9127   /* Cache this pointer-to-member type so that we can find it again
9128      later.  */
9129   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9130
9131   /* Seems to be wanted.  */
9132   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9133
9134   return t;
9135 }
9136
9137 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9138    Check to see that the definition is valid.  Issue appropriate error
9139    messages.  Return 1 if the definition is particularly bad, or 0
9140    otherwise.  */
9141
9142 int
9143 check_static_variable_definition (decl, type)
9144      tree decl;
9145      tree type;
9146 {
9147   /* Motion 10 at San Diego: If a static const integral data member is
9148      initialized with an integral constant expression, the initializer
9149      may appear either in the declaration (within the class), or in
9150      the definition, but not both.  If it appears in the class, the
9151      member is a member constant.  The file-scope definition is always
9152      required.  */
9153   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9154     {
9155       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9156                 type);
9157       /* If we just return the declaration, crashes will sometimes
9158          occur.  We therefore return void_type_node, as if this was a
9159          friend declaration, to cause callers to completely ignore
9160          this declaration.  */
9161       return 1;
9162     }
9163   else if (!CP_TYPE_CONST_P (type))
9164     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9165               decl);
9166   else if (pedantic && !INTEGRAL_TYPE_P (type))
9167     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9168
9169   return 0;
9170 }
9171
9172 /* Given the SIZE (i.e., number of elements) in an array, compute an
9173    appropriate index type for the array.  If non-NULL, NAME is the
9174    name of the thing being declared.  */
9175
9176 tree
9177 compute_array_index_type (name, size)
9178      tree name;
9179      tree size;
9180 {
9181   tree itype;
9182
9183   /* The size might be the result of a cast. */
9184   STRIP_TYPE_NOPS (size);
9185
9186   /* It might be a const variable or enumeration constant.  */
9187   size = decl_constant_value (size);
9188
9189   /* If this involves a template parameter, it will be a constant at
9190      instantiation time, but we don't know what the value is yet.
9191      Even if no template parameters are involved, we may an expression
9192      that is not a constant; we don't even simplify `1 + 2' when
9193      processing a template.  */
9194   if (processing_template_decl)
9195     {
9196       /* Resolve a qualified reference to an enumerator or static
9197          const data member of ours.  */
9198       if (TREE_CODE (size) == SCOPE_REF
9199           && TREE_OPERAND (size, 0) == current_class_type)
9200         {
9201           tree t = lookup_field (current_class_type,
9202                                  TREE_OPERAND (size, 1), 0, 0);
9203           if (t)
9204             size = t;
9205         }
9206
9207       return build_index_type (build_min (MINUS_EXPR, sizetype,
9208                                           size, integer_one_node));
9209     }
9210
9211   /* The array bound must be an integer type.  */
9212   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9213       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9214       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9215     {
9216       if (name)
9217         cp_error ("size of array `%D' has non-integer type", name);
9218       else
9219         cp_error ("size of array has non-integer type");
9220       size = integer_one_node;
9221     }
9222
9223   /* Normally, the array-bound will be a constant.  */
9224   if (TREE_CODE (size) == INTEGER_CST)
9225     {
9226       /* Check to see if the array bound overflowed.  Make that an
9227          error, no matter how generous we're being.  */
9228       int old_flag_pedantic_errors = flag_pedantic_errors;
9229       int old_pedantic = pedantic;
9230       pedantic = flag_pedantic_errors = 1;
9231       constant_expression_warning (size);
9232       pedantic = old_pedantic;
9233       flag_pedantic_errors = old_flag_pedantic_errors;
9234
9235       /* An array must have a positive number of elements.  */
9236       if (INT_CST_LT (size, integer_zero_node))
9237         {
9238           if (name)
9239             cp_error ("size of array `%D' is negative", name);
9240           else
9241             cp_error ("size of array is negative");
9242           size = integer_one_node;
9243         }
9244       /* Except that an extension we allow zero-sized arrays.  We
9245          always allow them in system headers because glibc uses
9246          them.  */
9247       else if (integer_zerop (size) && pedantic && !in_system_header)
9248         {
9249           if (name)
9250             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9251           else
9252             cp_pedwarn ("ISO C++ forbids zero-size array");
9253         }
9254     }
9255   else if (TREE_CONSTANT (size))
9256     {
9257       /* `(int) &fn' is not a valid array bound.  */
9258       if (name)
9259         cp_error ("size of array `%D' is not an integral constant-expression",
9260                   name);
9261       else
9262         cp_error ("size of array is not an integral constant-expression");
9263     }
9264
9265   /* Compute the index of the largest element in the array.  It is
9266      one less than the number of elements in the array.  */
9267   itype
9268     = fold (cp_build_binary_op (MINUS_EXPR,
9269                                 cp_convert (ssizetype, size),
9270                                 cp_convert (ssizetype,
9271                                             integer_one_node)));
9272
9273   /* Check for variable-sized arrays.  We allow such things as an
9274      extension, even though they are not allowed in ANSI/ISO C++.  */
9275   if (!TREE_CONSTANT (itype))
9276     {
9277       if (pedantic)
9278         {
9279           if (name)
9280             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9281                         name);
9282           else
9283             cp_pedwarn ("ISO C++ forbids variable-size array");
9284         }
9285
9286       /* Create a variable-sized array index type.  */
9287       itype = variable_size (itype);
9288     }
9289   /* Make sure that there was no overflow when creating to a signed
9290      index type.  (For example, on a 32-bit machine, an array with
9291      size 2^32 - 1 is too big.)  */
9292   else if (TREE_OVERFLOW (itype))
9293     {
9294       error ("overflow in array dimension");
9295       TREE_OVERFLOW (itype) = 0;
9296     }
9297
9298   /* Create and return the appropriate index type.  */
9299   return build_index_type (itype);
9300 }
9301
9302 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9303    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9304    with this type.  */
9305
9306 static tree
9307 create_array_type_for_decl (name, type, size)
9308      tree name;
9309      tree type;
9310      tree size;
9311 {
9312   tree itype = NULL_TREE;
9313   const char* error_msg;
9314
9315   /* If things have already gone awry, bail now.  */
9316   if (type == error_mark_node || size == error_mark_node)
9317     return error_mark_node;
9318
9319   /* Assume that everything will go OK.  */
9320   error_msg = NULL;
9321
9322   /* There are some types which cannot be array elements.  */
9323   switch (TREE_CODE (type))
9324     {
9325     case VOID_TYPE:
9326       error_msg = "array of void";
9327       break;
9328
9329     case FUNCTION_TYPE:
9330       error_msg = "array of functions";
9331       break;
9332
9333     case REFERENCE_TYPE:
9334       error_msg = "array of references";
9335       break;
9336
9337     case OFFSET_TYPE:
9338       error_msg = "array of data members";
9339       break;
9340
9341     case METHOD_TYPE:
9342       error_msg = "array of function members";
9343       break;
9344
9345     default:
9346       break;
9347     }
9348
9349   /* If something went wrong, issue an error-message and return.  */
9350   if (error_msg)
9351     {
9352       if (name)
9353         cp_error ("declaration of `%D' as %s", name, error_msg);
9354       else
9355         cp_error ("creating %s", error_msg);
9356
9357       return error_mark_node;
9358     }
9359
9360   /* [dcl.array]
9361
9362      The constant expressions that specify the bounds of the arrays
9363      can be omitted only for the first member of the sequence.  */
9364   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9365     {
9366       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9367                 name);
9368
9369       return error_mark_node;
9370     }
9371
9372   /* Figure out the index type for the array.  */
9373   if (size)
9374     itype = compute_array_index_type (name, size);
9375
9376   return build_cplus_array_type (type, itype);
9377 }
9378
9379 /* Check that it's OK to declare a function with the indicated TYPE.
9380    SFK indicates the kind of special function (if any) that this
9381    function is.  CTYPE is the class of which this function is a
9382    member.  OPTYPE is the type given in a conversion operator
9383    declaration.  Returns the actual return type of the function; that
9384    may be different than TYPE if an error occurs, or for certain
9385    special functions.  */
9386
9387 static tree
9388 check_special_function_return_type (sfk, type, ctype, optype)
9389      special_function_kind sfk;
9390      tree type;
9391      tree ctype;
9392      tree optype;
9393 {
9394   switch (sfk)
9395     {
9396     case sfk_constructor:
9397       if (type)
9398         cp_error ("return type specification for constructor invalid");
9399
9400       /* In the old ABI, we return `this'; in the new ABI we don't
9401          bother.  */
9402       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9403       break;
9404
9405     case sfk_destructor:
9406       if (type)
9407         cp_error ("return type specification for destructor invalid");
9408       type = void_type_node;
9409       break;
9410
9411     case sfk_conversion:
9412       if (type && !same_type_p (type, optype))
9413         cp_error ("operator `%T' declared to return `%T'", optype, type);
9414       else if (type)
9415         cp_pedwarn ("return type specified for `operator %T'",  optype);
9416       type = optype;
9417       break;
9418
9419     default:
9420       my_friendly_abort (20000408);
9421       break;
9422     }
9423
9424   return type;
9425 }
9426
9427 /* Given declspecs and a declarator,
9428    determine the name and type of the object declared
9429    and construct a ..._DECL node for it.
9430    (In one case we can return a ..._TYPE node instead.
9431     For invalid input we sometimes return 0.)
9432
9433    DECLSPECS is a chain of tree_list nodes whose value fields
9434     are the storage classes and type specifiers.
9435
9436    DECL_CONTEXT says which syntactic context this declaration is in:
9437      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9438      FUNCDEF for a function definition.  Like NORMAL but a few different
9439       error messages in each case.  Return value may be zero meaning
9440       this definition is too screwy to try to parse.
9441      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9442       handle member functions (which have FIELD context).
9443       Return value may be zero meaning this definition is too screwy to
9444       try to parse.
9445      PARM for a parameter declaration (either within a function prototype
9446       or before a function body).  Make a PARM_DECL, or return void_type_node.
9447      CATCHPARM for a parameter declaration before a catch clause.
9448      TYPENAME if for a typename (in a cast or sizeof).
9449       Don't make a DECL node; just return the ..._TYPE node.
9450      FIELD for a struct or union field; make a FIELD_DECL.
9451      BITFIELD for a field with specified width.
9452    INITIALIZED is 1 if the decl has an initializer.
9453
9454    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9455    normal attributes in TREE_PURPOSE, or NULL_TREE.
9456
9457    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9458    It may also be so in the PARM case, for a prototype where the
9459    argument type is specified but not the name.
9460
9461    This function is where the complicated C meanings of `static'
9462    and `extern' are interpreted.
9463
9464    For C++, if there is any monkey business to do, the function which
9465    calls this one must do it, i.e., prepending instance variables,
9466    renaming overloaded function names, etc.
9467
9468    Note that for this C++, it is an error to define a method within a class
9469    which does not belong to that class.
9470
9471    Except in the case where SCOPE_REFs are implicitly known (such as
9472    methods within a class being redundantly qualified),
9473    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9474    (class_name::decl_name).  The caller must also deal with this.
9475
9476    If a constructor or destructor is seen, and the context is FIELD,
9477    then the type gains the attribute TREE_HAS_x.  If such a declaration
9478    is erroneous, NULL_TREE is returned.
9479
9480    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9481    function, these are the qualifiers to give to the `this' pointer. We
9482    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9483
9484    May return void_type_node if the declarator turned out to be a friend.
9485    See grokfield for details.  */
9486
9487 tree
9488 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9489      tree declspecs;
9490      tree declarator;
9491      enum decl_context decl_context;
9492      int initialized;
9493      tree attrlist;
9494 {
9495   RID_BIT_TYPE specbits;
9496   int nclasses = 0;
9497   tree spec;
9498   tree type = NULL_TREE;
9499   int longlong = 0;
9500   int constp;
9501   int restrictp;
9502   int volatilep;
9503   int type_quals;
9504   int virtualp, explicitp, friendp, inlinep, staticp;
9505   int explicit_int = 0;
9506   int explicit_char = 0;
9507   int defaulted_int = 0;
9508   tree typedef_decl = NULL_TREE;
9509   const char *name;
9510   tree typedef_type = NULL_TREE;
9511   int funcdef_flag = 0;
9512   enum tree_code innermost_code = ERROR_MARK;
9513   int bitfield = 0;
9514 #if 0
9515   /* See the code below that used this.  */
9516   tree decl_machine_attr = NULL_TREE;
9517 #endif
9518   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9519      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9520   tree init = NULL_TREE;
9521
9522   /* Keep track of what sort of function is being processed
9523      so that we can warn about default return values, or explicit
9524      return values which do not match prescribed defaults.  */
9525   special_function_kind sfk = sfk_none;
9526
9527   tree dname = NULL_TREE;
9528   tree ctype = current_class_type;
9529   tree ctor_return_type = NULL_TREE;
9530   enum overload_flags flags = NO_SPECIAL;
9531   tree quals = NULL_TREE;
9532   tree raises = NULL_TREE;
9533   int template_count = 0;
9534   tree in_namespace = NULL_TREE;
9535   tree inner_attrs;
9536   int ignore_attrs;
9537
9538   RIDBIT_RESET_ALL (specbits);
9539   if (decl_context == FUNCDEF)
9540     funcdef_flag = 1, decl_context = NORMAL;
9541   else if (decl_context == MEMFUNCDEF)
9542     funcdef_flag = -1, decl_context = FIELD;
9543   else if (decl_context == BITFIELD)
9544     bitfield = 1, decl_context = FIELD;
9545
9546   /* Look inside a declarator for the name being declared
9547      and get it as a string, for an error message.  */
9548   {
9549     tree *next = &declarator;
9550     register tree decl;
9551     name = NULL;
9552
9553     while (next && *next)
9554       {
9555         decl = *next;
9556         switch (TREE_CODE (decl))
9557           {
9558           case TREE_LIST:
9559             /* For attributes.  */
9560             next = &TREE_VALUE (decl);
9561             break;
9562
9563           case COND_EXPR:
9564             ctype = NULL_TREE;
9565             next = &TREE_OPERAND (decl, 0);
9566             break;
9567
9568           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9569             {
9570               tree name = TREE_OPERAND (decl, 0);
9571               tree rename = NULL_TREE;
9572
9573               my_friendly_assert (flags == NO_SPECIAL, 152);
9574               flags = DTOR_FLAG;
9575               sfk = sfk_destructor;
9576               if (TREE_CODE (name) == TYPE_DECL)
9577                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9578               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9579               if (ctype == NULL_TREE)
9580                 {
9581                   if (current_class_type == NULL_TREE)
9582                     {
9583                       error ("destructors must be member functions");
9584                       flags = NO_SPECIAL;
9585                     }
9586                   else
9587                     {
9588                       tree t = constructor_name (current_class_name);
9589                       if (t != name)
9590                         rename = t;
9591                     }
9592                 }
9593               else
9594                 {
9595                   tree t = constructor_name (ctype);
9596                   if (t != name)
9597                     rename = t;
9598                 }
9599
9600               if (rename)
9601                 {
9602                   cp_error ("destructor `%T' must match class name `%T'",
9603                             name, rename);
9604                   TREE_OPERAND (decl, 0) = rename;
9605                 }
9606               next = &name;
9607             }
9608             break;
9609
9610           case ADDR_EXPR:       /* C++ reference declaration */
9611             /* Fall through. */
9612           case ARRAY_REF:
9613           case INDIRECT_REF:
9614             ctype = NULL_TREE;
9615             innermost_code = TREE_CODE (decl);
9616             next = &TREE_OPERAND (decl, 0);
9617             break;
9618
9619           case CALL_EXPR:
9620             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9621               {
9622                 /* This is actually a variable declaration using
9623                    constructor syntax.  We need to call start_decl and
9624                    cp_finish_decl so we can get the variable
9625                    initialized...  */
9626
9627                 tree attributes, prefix_attributes;
9628
9629                 *next = TREE_OPERAND (decl, 0);
9630                 init = CALL_DECLARATOR_PARMS (decl);
9631
9632                 if (attrlist)
9633                   {
9634                     attributes = TREE_PURPOSE (attrlist);
9635                     prefix_attributes = TREE_VALUE (attrlist);
9636                   }
9637                 else
9638                   {
9639                     attributes = NULL_TREE;
9640                     prefix_attributes = NULL_TREE;
9641                   }
9642
9643                 decl = start_decl (declarator, declspecs, 1,
9644                                    attributes, prefix_attributes);
9645                 decl_type_access_control (decl);
9646                 if (decl)
9647                   {
9648                     /* Look for __unused__ attribute */
9649                     if (TREE_USED (TREE_TYPE (decl)))
9650                       TREE_USED (decl) = 1;
9651                     finish_decl (decl, init, NULL_TREE);
9652                   }
9653                 else
9654                   cp_error ("invalid declarator");
9655                 return 0;
9656               }
9657             innermost_code = TREE_CODE (decl);
9658             if (decl_context == FIELD && ctype == NULL_TREE)
9659               ctype = current_class_type;
9660             if (ctype
9661                 && TREE_OPERAND (decl, 0)
9662                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9663                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9664                          == constructor_name_full (ctype))
9665                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9666                             == constructor_name (ctype)))))
9667               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9668             next = &TREE_OPERAND (decl, 0);
9669             decl = *next;
9670             if (ctype != NULL_TREE
9671                 && decl != NULL_TREE && flags != DTOR_FLAG
9672                 && decl == constructor_name (ctype))
9673               {
9674                 sfk = sfk_constructor;
9675                 ctor_return_type = ctype;
9676               }
9677             ctype = NULL_TREE;
9678             break;
9679
9680           case TEMPLATE_ID_EXPR:
9681               {
9682                 tree fns = TREE_OPERAND (decl, 0);
9683
9684                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9685                   fns = TREE_OPERAND (fns, 0);
9686
9687                 dname = fns;
9688                 if (TREE_CODE (dname) == COMPONENT_REF)
9689                   dname = TREE_OPERAND (dname, 1);
9690                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9691                   {
9692                     my_friendly_assert (is_overloaded_fn (dname),
9693                                         19990331);
9694                     dname = DECL_NAME (get_first_fn (dname));
9695                   }
9696               }
9697           /* Fall through. */
9698
9699           case IDENTIFIER_NODE:
9700             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9701               dname = decl;
9702
9703             next = 0;
9704
9705             if (C_IS_RESERVED_WORD (dname))
9706               {
9707                 cp_error ("declarator-id missing; using reserved word `%D'",
9708                           dname);
9709                 name = IDENTIFIER_POINTER (dname);
9710               }
9711             else if (!IDENTIFIER_TYPENAME_P (dname))
9712               name = IDENTIFIER_POINTER (dname);
9713             else
9714               {
9715                 my_friendly_assert (flags == NO_SPECIAL, 154);
9716                 flags = TYPENAME_FLAG;
9717                 ctor_return_type = TREE_TYPE (dname);
9718                 sfk = sfk_conversion;
9719                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9720                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9721                         == TYPE_DECL))
9722                   name = IDENTIFIER_POINTER (dname);
9723                 else
9724                   name = "<invalid operator>";
9725               }
9726             break;
9727
9728             /* C++ extension */
9729           case SCOPE_REF:
9730             {
9731               /* Perform error checking, and decide on a ctype.  */
9732               tree cname = TREE_OPERAND (decl, 0);
9733               if (cname == NULL_TREE)
9734                 ctype = NULL_TREE;
9735               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9736                 {
9737                   ctype = NULL_TREE;
9738                   in_namespace = TREE_OPERAND (decl, 0);
9739                   TREE_OPERAND (decl, 0) = NULL_TREE;
9740                 }
9741               else if (! is_aggr_type (cname, 1))
9742                 TREE_OPERAND (decl, 0) = NULL_TREE;
9743               /* Must test TREE_OPERAND (decl, 1), in case user gives
9744                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9745               else if (TREE_OPERAND (decl, 1)
9746                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9747                 ctype = cname;
9748               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9749                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9750                 {
9751                   cp_error ("`%T::%D' is not a valid declarator", cname,
9752                             TREE_OPERAND (decl, 1));
9753                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9754                             cname, TREE_OPERAND (decl, 1));
9755                   return void_type_node;
9756                 }
9757               else if (ctype == NULL_TREE)
9758                 ctype = cname;
9759               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9760                 TREE_OPERAND (decl, 0) = ctype;
9761               else
9762                 {
9763                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9764                     {
9765                       cp_error ("type `%T' is not derived from type `%T'",
9766                                 cname, ctype);
9767                       TREE_OPERAND (decl, 0) = NULL_TREE;
9768                     }
9769                   else
9770                     ctype = cname;
9771                 }
9772
9773               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9774                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9775                        == constructor_name_full (ctype))
9776                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9777                           == constructor_name (ctype))))
9778                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9779               next = &TREE_OPERAND (decl, 1);
9780               decl = *next;
9781               if (ctype)
9782                 {
9783                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9784                       && constructor_name (ctype) == decl)
9785                     {
9786                       sfk = sfk_constructor;
9787                       ctor_return_type = ctype;
9788                     }
9789                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9790                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9791                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9792                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9793                     {
9794                       sfk = sfk_destructor;
9795                       ctor_return_type = ctype;
9796                       flags = DTOR_FLAG;
9797                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9798                       next = &TREE_OPERAND (decl, 0);
9799                     }
9800                 }
9801             }
9802             break;
9803
9804           case ERROR_MARK:
9805             next = 0;
9806             break;
9807
9808           case TYPE_DECL:
9809             /* Parse error puts this typespec where
9810                a declarator should go.  */
9811             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9812             if (TREE_TYPE (decl) == current_class_type)
9813               cp_error ("  perhaps you want `%T' for a constructor",
9814                         current_class_name);
9815             dname = DECL_NAME (decl);
9816             name = IDENTIFIER_POINTER (dname);
9817
9818             /* Avoid giving two errors for this.  */
9819             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9820
9821             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9822             *next = dname;
9823             next = 0;
9824             break;
9825
9826           default:
9827             cp_compiler_error ("`%D' as declarator", decl);
9828             return 0; /* We used to do a 155 abort here.  */
9829           }
9830       }
9831   }
9832
9833   /* A function definition's declarator must have the form of
9834      a function declarator.  */
9835
9836   if (funcdef_flag && innermost_code != CALL_EXPR)
9837     return 0;
9838
9839   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9840       && innermost_code != CALL_EXPR
9841       && ! (ctype && declspecs == NULL_TREE))
9842     {
9843       cp_error ("declaration of `%D' as non-function", dname);
9844       return void_type_node;
9845     }
9846
9847   /* Anything declared one level down from the top level
9848      must be one of the parameters of a function
9849      (because the body is at least two levels down).  */
9850
9851   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9852      by not allowing C++ class definitions to specify their parameters
9853      with xdecls (must be spec.d in the parmlist).
9854
9855      Since we now wait to push a class scope until we are sure that
9856      we are in a legitimate method context, we must set oldcname
9857      explicitly (since current_class_name is not yet alive).
9858
9859      We also want to avoid calling this a PARM if it is in a namespace.  */
9860
9861   if (decl_context == NORMAL && !toplevel_bindings_p ())
9862     {
9863       struct binding_level *b = current_binding_level;
9864       current_binding_level = b->level_chain;
9865       if (current_binding_level != 0 && toplevel_bindings_p ())
9866         decl_context = PARM;
9867       current_binding_level = b;
9868     }
9869
9870   if (name == NULL)
9871     name = decl_context == PARM ? "parameter" : "type name";
9872
9873   /* Look through the decl specs and record which ones appear.
9874      Some typespecs are defined as built-in typenames.
9875      Others, the ones that are modifiers of other types,
9876      are represented by bits in SPECBITS: set the bits for
9877      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9878
9879      If there is a typedef name or a type, store the type in TYPE.
9880      This includes builtin typedefs such as `int'.
9881
9882      Set EXPLICIT_INT if the type is `int' or `char' and did not
9883      come from a user typedef.
9884
9885      Set LONGLONG if `long' is mentioned twice.
9886
9887      For C++, constructors and destructors have their own fast treatment.  */
9888
9889   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9890     {
9891       register int i;
9892       register tree id;
9893
9894       /* Certain parse errors slip through.  For example,
9895          `int class;' is not caught by the parser. Try
9896          weakly to recover here.  */
9897       if (TREE_CODE (spec) != TREE_LIST)
9898         return 0;
9899
9900       id = TREE_VALUE (spec);
9901
9902       if (TREE_CODE (id) == IDENTIFIER_NODE)
9903         {
9904           if (id == ridpointers[(int) RID_INT]
9905               || id == ridpointers[(int) RID_CHAR]
9906               || id == ridpointers[(int) RID_BOOL]
9907               || id == ridpointers[(int) RID_WCHAR])
9908             {
9909               if (type)
9910                 {
9911                   if (id == ridpointers[(int) RID_BOOL])
9912                     error ("`bool' is now a keyword");
9913                   else
9914                     cp_error ("extraneous `%T' ignored", id);
9915                 }
9916               else
9917                 {
9918                   if (id == ridpointers[(int) RID_INT])
9919                     explicit_int = 1;
9920                   else if (id == ridpointers[(int) RID_CHAR])
9921                     explicit_char = 1;
9922                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9923                 }
9924               goto found;
9925             }
9926           /* C++ aggregate types.  */
9927           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9928             {
9929               if (type)
9930                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9931               else
9932                 type = IDENTIFIER_TYPE_VALUE (id);
9933               goto found;
9934             }
9935
9936           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9937             {
9938               if (ridpointers[i] == id)
9939                 {
9940                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9941                     {
9942                       if (pedantic && ! in_system_header && warn_long_long)
9943                         pedwarn ("ISO C++ does not support `long long'");
9944                       if (longlong)
9945                         error ("`long long long' is too long for GCC");
9946                       else
9947                         longlong = 1;
9948                     }
9949                   else if (RIDBIT_SETP (i, specbits))
9950                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9951                   RIDBIT_SET (i, specbits);
9952                   goto found;
9953                 }
9954             }
9955         }
9956       /* C++ aggregate types.  */
9957       else if (TREE_CODE (id) == TYPE_DECL)
9958         {
9959           if (type)
9960             cp_error ("multiple declarations `%T' and `%T'", type,
9961                       TREE_TYPE (id));
9962           else
9963             {
9964               type = TREE_TYPE (id);
9965               TREE_VALUE (spec) = type;
9966             }
9967           goto found;
9968         }
9969       if (type)
9970         error ("two or more data types in declaration of `%s'", name);
9971       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9972         {
9973           register tree t = lookup_name (id, 1);
9974           if (!t || TREE_CODE (t) != TYPE_DECL)
9975             error ("`%s' fails to be a typedef or built in type",
9976                    IDENTIFIER_POINTER (id));
9977           else
9978             {
9979               type = TREE_TYPE (t);
9980 #if 0
9981               /* See the code below that used this.  */
9982               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9983 #endif
9984               typedef_decl = t;
9985             }
9986         }
9987       else if (id != error_mark_node)
9988         /* Can't change CLASS nodes into RECORD nodes here!  */
9989         type = id;
9990
9991     found: ;
9992     }
9993
9994   typedef_type = type;
9995
9996   /* No type at all: default to `int', and set DEFAULTED_INT
9997      because it was not a user-defined typedef.  */
9998
9999   if (type == NULL_TREE
10000       && (RIDBIT_SETP (RID_SIGNED, specbits)
10001           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10002           || RIDBIT_SETP (RID_LONG, specbits)
10003           || RIDBIT_SETP (RID_SHORT, specbits)))
10004     {
10005       /* These imply 'int'.  */
10006       type = integer_type_node;
10007       defaulted_int = 1;
10008     }
10009
10010   if (sfk != sfk_none)
10011     type = check_special_function_return_type (sfk, type,
10012                                                ctor_return_type,
10013                                                ctor_return_type);
10014   else if (type == NULL_TREE)
10015     {
10016       int is_main;
10017
10018       explicit_int = -1;
10019
10020           /* We handle `main' specially here, because 'main () { }' is so
10021              common.  With no options, it is allowed.  With -Wreturn-type,
10022              it is a warning.  It is only an error with -pedantic-errors.  */
10023       is_main = (funcdef_flag
10024                  && MAIN_NAME_P (dname)
10025                  && ctype == NULL_TREE
10026                  && in_namespace == NULL_TREE
10027                  && current_namespace == global_namespace);
10028
10029       if (in_system_header || flag_ms_extensions)
10030         /* Allow it, sigh.  */;
10031       else if (pedantic || ! is_main)
10032         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10033                     name);
10034       else if (warn_return_type)
10035         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10036                     name);
10037
10038       type = integer_type_node;
10039     }
10040
10041   ctype = NULL_TREE;
10042
10043   /* Now process the modifiers that were specified
10044      and check for invalid combinations.  */
10045
10046   /* Long double is a special combination.  */
10047
10048   if (RIDBIT_SETP (RID_LONG, specbits)
10049       && TYPE_MAIN_VARIANT (type) == double_type_node)
10050     {
10051       RIDBIT_RESET (RID_LONG, specbits);
10052       type = build_qualified_type (long_double_type_node,
10053                                    CP_TYPE_QUALS (type));
10054     }
10055
10056   /* Check all other uses of type modifiers.  */
10057
10058   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10059       || RIDBIT_SETP (RID_SIGNED, specbits)
10060       || RIDBIT_SETP (RID_LONG, specbits)
10061       || RIDBIT_SETP (RID_SHORT, specbits))
10062     {
10063       int ok = 0;
10064
10065       if (TREE_CODE (type) == REAL_TYPE)
10066         error ("short, signed or unsigned invalid for `%s'", name);
10067       else if (TREE_CODE (type) != INTEGER_TYPE)
10068         error ("long, short, signed or unsigned invalid for `%s'", name);
10069       else if (RIDBIT_SETP (RID_LONG, specbits)
10070                && RIDBIT_SETP (RID_SHORT, specbits))
10071         error ("long and short specified together for `%s'", name);
10072       else if ((RIDBIT_SETP (RID_LONG, specbits)
10073                 || RIDBIT_SETP (RID_SHORT, specbits))
10074                && explicit_char)
10075         error ("long or short specified with char for `%s'", name);
10076       else if ((RIDBIT_SETP (RID_LONG, specbits)
10077                 || RIDBIT_SETP (RID_SHORT, specbits))
10078                && TREE_CODE (type) == REAL_TYPE)
10079         error ("long or short specified with floating type for `%s'", name);
10080       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10081                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10082         error ("signed and unsigned given together for `%s'", name);
10083       else
10084         {
10085           ok = 1;
10086           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10087             {
10088               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10089                        name);
10090               if (flag_pedantic_errors)
10091                 ok = 0;
10092             }
10093         }
10094
10095       /* Discard the type modifiers if they are invalid.  */
10096       if (! ok)
10097         {
10098           RIDBIT_RESET (RID_UNSIGNED, specbits);
10099           RIDBIT_RESET (RID_SIGNED, specbits);
10100           RIDBIT_RESET (RID_LONG, specbits);
10101           RIDBIT_RESET (RID_SHORT, specbits);
10102           longlong = 0;
10103         }
10104     }
10105
10106   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10107       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10108     {
10109       error ("complex invalid for `%s'", name);
10110       RIDBIT_RESET (RID_COMPLEX, specbits);
10111     }
10112
10113   /* Decide whether an integer type is signed or not.
10114      Optionally treat bitfields as signed by default.  */
10115   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10116       /* [class.bit]
10117
10118          It is implementation-defined whether a plain (neither
10119          explicitly signed or unsigned) char, short, int, or long
10120          bit-field is signed or unsigned.
10121
10122          Naturally, we extend this to long long as well.  Note that
10123          this does not include wchar_t.  */
10124       || (bitfield && !flag_signed_bitfields
10125           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10126           /* A typedef for plain `int' without `signed' can be
10127              controlled just like plain `int', but a typedef for
10128              `signed int' cannot be so controlled.  */
10129           && !(typedef_decl
10130                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10131           && (TREE_CODE (type) == INTEGER_TYPE
10132               || TREE_CODE (type) == CHAR_TYPE)
10133           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10134     {
10135       if (longlong)
10136         type = long_long_unsigned_type_node;
10137       else if (RIDBIT_SETP (RID_LONG, specbits))
10138         type = long_unsigned_type_node;
10139       else if (RIDBIT_SETP (RID_SHORT, specbits))
10140         type = short_unsigned_type_node;
10141       else if (type == char_type_node)
10142         type = unsigned_char_type_node;
10143       else if (typedef_decl)
10144         type = unsigned_type (type);
10145       else
10146         type = unsigned_type_node;
10147     }
10148   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10149            && type == char_type_node)
10150     type = signed_char_type_node;
10151   else if (longlong)
10152     type = long_long_integer_type_node;
10153   else if (RIDBIT_SETP (RID_LONG, specbits))
10154     type = long_integer_type_node;
10155   else if (RIDBIT_SETP (RID_SHORT, specbits))
10156     type = short_integer_type_node;
10157
10158   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10159     {
10160       /* If we just have "complex", it is equivalent to
10161          "complex double", but if any modifiers at all are specified it is
10162          the complex form of TYPE.  E.g, "complex short" is
10163          "complex short int".  */
10164
10165       if (defaulted_int && ! longlong
10166           && ! (RIDBIT_SETP (RID_LONG, specbits)
10167                 || RIDBIT_SETP (RID_SHORT, specbits)
10168                 || RIDBIT_SETP (RID_SIGNED, specbits)
10169                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10170         type = complex_double_type_node;
10171       else if (type == integer_type_node)
10172         type = complex_integer_type_node;
10173       else if (type == float_type_node)
10174         type = complex_float_type_node;
10175       else if (type == double_type_node)
10176         type = complex_double_type_node;
10177       else if (type == long_double_type_node)
10178         type = complex_long_double_type_node;
10179       else
10180         type = build_complex_type (type);
10181     }
10182
10183   if (sfk == sfk_conversion
10184       && (RIDBIT_SETP (RID_CONST, specbits)
10185           || RIDBIT_SETP (RID_VOLATILE, specbits)
10186           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10187     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10188               ctor_return_type);
10189
10190   /* Set CONSTP if this declaration is `const', whether by
10191      explicit specification or via a typedef.
10192      Likewise for VOLATILEP.  */
10193
10194   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10195   restrictp =
10196     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10197   volatilep =
10198     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10199   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10200                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10201                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10202   type = cp_build_qualified_type (type, type_quals);
10203   staticp = 0;
10204   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10205   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10206   RIDBIT_RESET (RID_VIRTUAL, specbits);
10207   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10208   RIDBIT_RESET (RID_EXPLICIT, specbits);
10209
10210   if (RIDBIT_SETP (RID_STATIC, specbits))
10211     staticp = 1 + (decl_context == FIELD);
10212
10213   if (virtualp && staticp == 2)
10214     {
10215       cp_error ("member `%D' cannot be declared both virtual and static",
10216                 dname);
10217       staticp = 0;
10218     }
10219   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10220   RIDBIT_RESET (RID_FRIEND, specbits);
10221
10222   /* Warn if two storage classes are given. Default to `auto'.  */
10223
10224   if (RIDBIT_ANY_SET (specbits))
10225     {
10226       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10227       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10228       if (decl_context == PARM && nclasses > 0)
10229         error ("storage class specifiers invalid in parameter declarations");
10230       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10231         {
10232           if (decl_context == PARM)
10233             error ("typedef declaration invalid in parameter declaration");
10234           nclasses++;
10235         }
10236       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10237       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10238     }
10239
10240   /* Give error if `virtual' is used outside of class declaration.  */
10241   if (virtualp
10242       && (current_class_name == NULL_TREE || decl_context != FIELD))
10243     {
10244       error ("virtual outside class declaration");
10245       virtualp = 0;
10246     }
10247
10248   /* Static anonymous unions are dealt with here.  */
10249   if (staticp && decl_context == TYPENAME
10250       && TREE_CODE (declspecs) == TREE_LIST
10251       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10252     decl_context = FIELD;
10253
10254   /* Warn about storage classes that are invalid for certain
10255      kinds of declarations (parameters, typenames, etc.).  */
10256
10257   if (nclasses > 1)
10258     error ("multiple storage classes in declaration of `%s'", name);
10259   else if (decl_context != NORMAL && nclasses > 0)
10260     {
10261       if ((decl_context == PARM || decl_context == CATCHPARM)
10262           && (RIDBIT_SETP (RID_REGISTER, specbits)
10263               || RIDBIT_SETP (RID_AUTO, specbits)))
10264         ;
10265       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10266         ;
10267       else if (decl_context == FIELD
10268                /* C++ allows static class elements  */
10269                && RIDBIT_SETP (RID_STATIC, specbits))
10270         /* C++ also allows inlines and signed and unsigned elements,
10271            but in those cases we don't come in here.  */
10272         ;
10273       else
10274         {
10275           if (decl_context == FIELD)
10276             {
10277               tree tmp = NULL_TREE;
10278               register int op = 0;
10279
10280               if (declarator)
10281                 {
10282                   /* Avoid trying to get an operand off an identifier node.  */
10283                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10284                     tmp = declarator;
10285                   else
10286                     tmp = TREE_OPERAND (declarator, 0);
10287                   op = IDENTIFIER_OPNAME_P (tmp);
10288                   if (IDENTIFIER_TYPENAME_P (tmp))
10289                     {
10290                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10291                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10292                               == TYPE_DECL))
10293                         name = IDENTIFIER_POINTER (tmp);
10294                       else
10295                         name = "<invalid operator>";
10296                     }
10297                 }
10298               error ("storage class specified for %s `%s'",
10299                      op ? "member operator" : "field",
10300                      name);
10301             }
10302           else
10303             {
10304               if (decl_context == PARM || decl_context == CATCHPARM)
10305                 error ("storage class specified for parameter `%s'", name);
10306               else
10307                 error ("storage class specified for typename");
10308             }
10309           RIDBIT_RESET (RID_REGISTER, specbits);
10310           RIDBIT_RESET (RID_AUTO, specbits);
10311           RIDBIT_RESET (RID_EXTERN, specbits);
10312         }
10313     }
10314   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10315     {
10316       if (toplevel_bindings_p ())
10317         {
10318           /* It's common practice (and completely valid) to have a const
10319              be initialized and declared extern.  */
10320           if (!(type_quals & TYPE_QUAL_CONST))
10321             warning ("`%s' initialized and declared `extern'", name);
10322         }
10323       else
10324         error ("`%s' has both `extern' and initializer", name);
10325     }
10326   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10327            && ! toplevel_bindings_p ())
10328     error ("nested function `%s' declared `extern'", name);
10329   else if (toplevel_bindings_p ())
10330     {
10331       if (RIDBIT_SETP (RID_AUTO, specbits))
10332         error ("top-level declaration of `%s' specifies `auto'", name);
10333     }
10334
10335   if (nclasses > 0 && friendp)
10336     error ("storage class specifiers invalid in friend function declarations");
10337
10338   /* Now figure out the structure of the declarator proper.
10339      Descend through it, creating more complex types, until we reach
10340      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10341
10342   inner_attrs = NULL_TREE;
10343   ignore_attrs = 0;
10344
10345   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10346          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10347     {
10348       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10349          an INDIRECT_REF (for *...),
10350          a CALL_EXPR (for ...(...)),
10351          an identifier (for the name being declared)
10352          or a null pointer (for the place in an absolute declarator
10353          where the name was omitted).
10354          For the last two cases, we have just exited the loop.
10355
10356          For C++ it could also be
10357          a SCOPE_REF (for class :: ...).  In this case, we have converted
10358          sensible names to types, and those are the values we use to
10359          qualify the member name.
10360          an ADDR_EXPR (for &...),
10361          a BIT_NOT_EXPR (for destructors)
10362
10363          At this point, TYPE is the type of elements of an array,
10364          or for a function to return, or for a pointer to point to.
10365          After this sequence of ifs, TYPE is the type of the
10366          array or function or pointer, and DECLARATOR has had its
10367          outermost layer removed.  */
10368
10369       if (type == error_mark_node)
10370         {
10371           if (TREE_CODE (declarator) == SCOPE_REF)
10372             declarator = TREE_OPERAND (declarator, 1);
10373           else
10374             declarator = TREE_OPERAND (declarator, 0);
10375           continue;
10376         }
10377       if (quals != NULL_TREE
10378           && (declarator == NULL_TREE
10379               || TREE_CODE (declarator) != SCOPE_REF))
10380         {
10381           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10382             ctype = TYPE_METHOD_BASETYPE (type);
10383           if (ctype != NULL_TREE)
10384             {
10385               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10386               grok_method_quals (ctype, dummy, quals);
10387               type = TREE_TYPE (dummy);
10388               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10389               quals = NULL_TREE;
10390             }
10391         }
10392
10393       /* See the comment for the TREE_LIST case, below.  */
10394       if (ignore_attrs)
10395         ignore_attrs = 0;
10396       else if (inner_attrs)
10397         {
10398           decl_attributes (type, inner_attrs, NULL_TREE);
10399           inner_attrs = NULL_TREE;
10400         }
10401
10402       switch (TREE_CODE (declarator))
10403         {
10404         case TREE_LIST:
10405           {
10406             /* We encode a declarator with embedded attributes using
10407                a TREE_LIST.  The attributes apply to the declarator
10408                directly inside them, so we have to skip an iteration
10409                before applying them to the type.  If the declarator just
10410                inside is the declarator-id, we apply the attrs to the
10411                decl itself.  */
10412             inner_attrs = TREE_PURPOSE (declarator);
10413             ignore_attrs = 1;
10414             declarator = TREE_VALUE (declarator);
10415           }
10416           break;
10417
10418         case ARRAY_REF:
10419           {
10420             register tree size;
10421
10422             size = TREE_OPERAND (declarator, 1);
10423
10424             /* VC++ spells a zero-sized array with [].  */
10425             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10426                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10427               size = integer_zero_node;
10428
10429             declarator = TREE_OPERAND (declarator, 0);
10430
10431             type = create_array_type_for_decl (dname, type, size);
10432
10433             /* VLAs never work as fields. */
10434             if (decl_context == FIELD && !processing_template_decl
10435                 && TREE_CODE (type) == ARRAY_TYPE
10436                 && TYPE_DOMAIN (type) != NULL_TREE
10437                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10438               {
10439                 cp_error ("size of member `%D' is not constant", dname);
10440                 /* Proceed with arbitrary constant size, so that offset
10441                    computations don't get confused. */
10442                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10443                                                    integer_one_node);
10444               }
10445
10446             ctype = NULL_TREE;
10447           }
10448           break;
10449
10450         case CALL_EXPR:
10451           {
10452             tree arg_types;
10453             int funcdecl_p;
10454             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10455             tree inner_decl = TREE_OPERAND (declarator, 0);
10456
10457             /* Declaring a function type.
10458                Make sure we have a valid type for the function to return.  */
10459
10460             /* We now know that the TYPE_QUALS don't apply to the
10461                decl, but to its return type.  */
10462             type_quals = TYPE_UNQUALIFIED;
10463
10464             /* Warn about some types functions can't return.  */
10465
10466             if (TREE_CODE (type) == FUNCTION_TYPE)
10467               {
10468                 error ("`%s' declared as function returning a function", name);
10469                 type = integer_type_node;
10470               }
10471             if (TREE_CODE (type) == ARRAY_TYPE)
10472               {
10473                 error ("`%s' declared as function returning an array", name);
10474                 type = integer_type_node;
10475               }
10476
10477             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10478               inner_decl = TREE_OPERAND (inner_decl, 1);
10479
10480             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10481               inner_decl = dname;
10482
10483             /* Pick up type qualifiers which should be applied to `this'.  */
10484             quals = CALL_DECLARATOR_QUALS (declarator);
10485
10486             /* Pick up the exception specifications.  */
10487             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10488
10489             /* Say it's a definition only for the CALL_EXPR
10490                closest to the identifier.  */
10491             funcdecl_p
10492               = inner_decl
10493               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10494                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10495                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10496
10497             if (ctype == NULL_TREE
10498                 && decl_context == FIELD
10499                 && funcdecl_p
10500                 && (friendp == 0 || dname == current_class_name))
10501               ctype = current_class_type;
10502
10503             if (ctype && sfk == sfk_conversion)
10504               TYPE_HAS_CONVERSION (ctype) = 1;
10505             if (ctype && constructor_name (ctype) == dname)
10506               {
10507                 /* We are within a class's scope. If our declarator name
10508                    is the same as the class name, and we are defining
10509                    a function, then it is a constructor/destructor, and
10510                    therefore returns a void type.  */
10511
10512                 if (flags == DTOR_FLAG)
10513                   {
10514                     /* ISO C++ 12.4/2.  A destructor may not be
10515                        declared const or volatile.  A destructor may
10516                        not be static.  */
10517                     if (staticp == 2)
10518                       error ("destructor cannot be static member function");
10519                     if (quals)
10520                       {
10521                         cp_error ("destructors may not be `%s'",
10522                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10523                         quals = NULL_TREE;
10524                       }
10525                     if (decl_context == FIELD)
10526                       {
10527                         if (! member_function_or_else (ctype,
10528                                                        current_class_type,
10529                                                        flags))
10530                           return void_type_node;
10531                       }
10532                   }
10533                 else            /* It's a constructor.  */
10534                   {
10535                     if (explicitp == 1)
10536                       explicitp = 2;
10537                     /* ISO C++ 12.1.  A constructor may not be
10538                        declared const or volatile.  A constructor may
10539                        not be virtual.  A constructor may not be
10540                        static.  */
10541                     if (staticp == 2)
10542                       error ("constructor cannot be static member function");
10543                     if (virtualp)
10544                       {
10545                         pedwarn ("constructors cannot be declared virtual");
10546                         virtualp = 0;
10547                       }
10548                     if (quals)
10549                       {
10550                         cp_error ("constructors may not be `%s'",
10551                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10552                         quals = NULL_TREE;
10553                       }
10554                     {
10555                       RID_BIT_TYPE tmp_bits;
10556                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10557                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10558                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10559                       if (RIDBIT_ANY_SET (tmp_bits))
10560                         error ("return value type specifier for constructor ignored");
10561                     }
10562                     if (decl_context == FIELD)
10563                       {
10564                         if (! member_function_or_else (ctype,
10565                                                        current_class_type,
10566                                                        flags))
10567                           return void_type_node;
10568                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10569                         if (sfk != sfk_constructor)
10570                           return NULL_TREE;
10571                       }
10572                   }
10573                 if (decl_context == FIELD)
10574                   staticp = 0;
10575               }
10576             else if (friendp)
10577               {
10578                 if (initialized)
10579                   error ("can't initialize friend function `%s'", name);
10580                 if (virtualp)
10581                   {
10582                     /* Cannot be both friend and virtual.  */
10583                     error ("virtual functions cannot be friends");
10584                     RIDBIT_RESET (RID_FRIEND, specbits);
10585                     friendp = 0;
10586                   }
10587                 if (decl_context == NORMAL)
10588                   error ("friend declaration not in class definition");
10589                 if (current_function_decl && funcdef_flag)
10590                   cp_error ("can't define friend function `%s' in a local class definition",
10591                             name);
10592               }
10593
10594             /* Construct the function type and go to the next
10595                inner layer of declarator.  */
10596
10597             declarator = TREE_OPERAND (declarator, 0);
10598
10599             /* FIXME: This is where default args should be fully
10600                processed.  */
10601
10602             arg_types = grokparms (inner_parms);
10603
10604             if (declarator && flags == DTOR_FLAG)
10605               {
10606                 /* A destructor declared in the body of a class will
10607                    be represented as a BIT_NOT_EXPR.  But, we just
10608                    want the underlying IDENTIFIER.  */
10609                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10610                   declarator = TREE_OPERAND (declarator, 0);
10611
10612                 if (arg_types != void_list_node)
10613                   {
10614                     cp_error ("destructors may not have parameters");
10615                     arg_types = void_list_node;
10616                     last_function_parms = NULL_TREE;
10617                   }
10618               }
10619
10620             /* ANSI says that `const int foo ();'
10621                does not make the function foo const.  */
10622             type = build_function_type (type, arg_types);
10623
10624             {
10625               tree t;
10626               for (t = arg_types; t; t = TREE_CHAIN (t))
10627                 if (TREE_PURPOSE (t)
10628                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10629                   {
10630                     add_defarg_fn (type);
10631                     break;
10632                   }
10633             }
10634           }
10635           break;
10636
10637         case ADDR_EXPR:
10638         case INDIRECT_REF:
10639           /* Filter out pointers-to-references and references-to-references.
10640              We can get these if a TYPE_DECL is used.  */
10641
10642           if (TREE_CODE (type) == REFERENCE_TYPE)
10643             {
10644               error ("cannot declare %s to references",
10645                      TREE_CODE (declarator) == ADDR_EXPR
10646                      ? "references" : "pointers");
10647               declarator = TREE_OPERAND (declarator, 0);
10648               continue;
10649             }
10650
10651           if (TREE_CODE (type) == OFFSET_TYPE
10652               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10653                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10654             {
10655               cp_error ("cannot declare pointer to `%#T' member",
10656                         TREE_TYPE (type));
10657               type = TREE_TYPE (type);
10658             }
10659
10660           /* Merge any constancy or volatility into the target type
10661              for the pointer.  */
10662
10663           /* We now know that the TYPE_QUALS don't apply to the decl,
10664              but to the target of the pointer.  */
10665           type_quals = TYPE_UNQUALIFIED;
10666
10667           if (TREE_CODE (declarator) == ADDR_EXPR)
10668             {
10669               if (TREE_CODE (type) == VOID_TYPE)
10670                 error ("invalid type: `void &'");
10671               else
10672                 type = build_reference_type (type);
10673             }
10674           else if (TREE_CODE (type) == METHOD_TYPE)
10675             type = build_ptrmemfunc_type (build_pointer_type (type));
10676           else
10677             type = build_pointer_type (type);
10678
10679           /* Process a list of type modifier keywords (such as
10680              const or volatile) that were given inside the `*' or `&'.  */
10681
10682           if (TREE_TYPE (declarator))
10683             {
10684               register tree typemodlist;
10685               int erred = 0;
10686
10687               constp = 0;
10688               volatilep = 0;
10689               restrictp = 0;
10690               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10691                    typemodlist = TREE_CHAIN (typemodlist))
10692                 {
10693                   tree qualifier = TREE_VALUE (typemodlist);
10694
10695                   if (qualifier == ridpointers[(int) RID_CONST])
10696                     constp++;
10697                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10698                     volatilep++;
10699                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10700                     restrictp++;
10701                   else if (!erred)
10702                     {
10703                       erred = 1;
10704                       error ("invalid type modifier within pointer declarator");
10705                     }
10706                 }
10707               if (constp > 1)
10708                 pedwarn ("duplicate `const'");
10709               if (volatilep > 1)
10710                 pedwarn ("duplicate `volatile'");
10711               if (restrictp > 1)
10712                 pedwarn ("duplicate `restrict'");
10713
10714               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10715                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10716                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10717               if (TREE_CODE (declarator) == ADDR_EXPR
10718                   && (constp || volatilep))
10719                 {
10720                   if (constp)
10721                     pedwarn ("discarding `const' applied to a reference");
10722                   if (volatilep)
10723                     pedwarn ("discarding `volatile' applied to a reference");
10724                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10725                 }
10726               type = cp_build_qualified_type (type, type_quals);
10727             }
10728           declarator = TREE_OPERAND (declarator, 0);
10729           ctype = NULL_TREE;
10730           break;
10731
10732         case SCOPE_REF:
10733           {
10734             /* We have converted type names to NULL_TREE if the
10735                name was bogus, or to a _TYPE node, if not.
10736
10737                The variable CTYPE holds the type we will ultimately
10738                resolve to.  The code here just needs to build
10739                up appropriate member types.  */
10740             tree sname = TREE_OPERAND (declarator, 1);
10741             tree t;
10742
10743             /* Destructors can have their visibilities changed as well.  */
10744             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10745               sname = TREE_OPERAND (sname, 0);
10746
10747             if (TREE_COMPLEXITY (declarator) == 0)
10748               /* This needs to be here, in case we are called
10749                  multiple times.  */ ;
10750             else if (TREE_COMPLEXITY (declarator) == -1)
10751               /* Namespace member. */
10752               pop_decl_namespace ();
10753             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10754               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10755             else if (! IS_AGGR_TYPE_CODE
10756                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10757               ;
10758             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10759               {
10760                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10761                    that refer to ctype.  They couldn't be resolved earlier
10762                    because we hadn't pushed into the class yet.
10763                    Example: resolve 'B<T>::type' in
10764                    'B<typename B<T>::type> B<T>::f () { }'.  */
10765                 if (current_template_parms
10766                     && uses_template_parms (type)
10767                     && uses_template_parms (current_class_type))
10768                   {
10769                     tree args = current_template_args ();
10770                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10771                   }
10772
10773                 /* This pop_nested_class corresponds to the
10774                    push_nested_class used to push into class scope for
10775                    parsing the argument list of a function decl, in
10776                    qualified_id.  */
10777                 pop_nested_class ();
10778                 TREE_COMPLEXITY (declarator) = current_class_depth;
10779               }
10780             else
10781               my_friendly_abort (16);
10782
10783             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10784               {
10785                 /* We had a reference to a global decl, or
10786                    perhaps we were given a non-aggregate typedef,
10787                    in which case we cleared this out, and should just
10788                    keep going as though it wasn't there.  */
10789                 declarator = sname;
10790                 continue;
10791               }
10792             ctype = TREE_OPERAND (declarator, 0);
10793
10794             t = ctype;
10795             while (t != NULL_TREE && CLASS_TYPE_P (t))
10796               {
10797                 /* You're supposed to have one `template <...>'
10798                    for every template class, but you don't need one
10799                    for a full specialization.  For example:
10800
10801                      template <class T> struct S{};
10802                      template <> struct S<int> { void f(); };
10803                      void S<int>::f () {}
10804
10805                    is correct; there shouldn't be a `template <>' for
10806                    the definition of `S<int>::f'.  */
10807                 if (CLASSTYPE_TEMPLATE_INFO (t)
10808                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10809                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10810                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10811                   template_count += 1;
10812
10813                 t = TYPE_MAIN_DECL (t);
10814                 t = DECL_CONTEXT (t);
10815               }
10816
10817             if (sname == NULL_TREE)
10818               goto done_scoping;
10819
10820             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10821               {
10822                 /* This is the `standard' use of the scoping operator:
10823                    basetype :: member .  */
10824
10825                 if (ctype == current_class_type)
10826                   {
10827                     /* class A {
10828                          void A::f ();
10829                        };
10830
10831                        Is this ill-formed?  */
10832
10833                     if (pedantic)
10834                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10835                                   ctype, name);
10836                   }
10837                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10838                   {
10839                     if (current_class_type == NULL_TREE || friendp)
10840                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10841                                                       TYPE_ARG_TYPES (type));
10842                     else
10843                       {
10844                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10845                                   ctype, name, current_class_type);
10846                         return void_type_node;
10847                       }
10848                   }
10849                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10850                          || COMPLETE_TYPE_P (complete_type (ctype)))
10851                   {
10852                     /* Have to move this code elsewhere in this function.
10853                        this code is used for i.e., typedef int A::M; M *pm;
10854
10855                        It is?  How? jason 10/2/94 */
10856
10857                     if (current_class_type)
10858                       {
10859                         cp_error ("cannot declare member `%T::%s' within `%T'",
10860                                   ctype, name, current_class_type);
10861                         return void_type_node;
10862                       }
10863                     type = build_offset_type (ctype, type);
10864                   }
10865                 else
10866                   {
10867                     incomplete_type_error (NULL_TREE, ctype);
10868                     return error_mark_node;
10869                   }
10870
10871                 declarator = sname;
10872               }
10873             else if (TREE_CODE (sname) == SCOPE_REF)
10874               my_friendly_abort (17);
10875             else
10876               {
10877               done_scoping:
10878                 declarator = TREE_OPERAND (declarator, 1);
10879                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10880                   /* In this case, we will deal with it later.  */
10881                   ;
10882                 else
10883                   {
10884                     if (TREE_CODE (type) == FUNCTION_TYPE)
10885                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10886                                                       TYPE_ARG_TYPES (type));
10887                     else
10888                       type = build_offset_type (ctype, type);
10889                   }
10890               }
10891           }
10892           break;
10893
10894         case BIT_NOT_EXPR:
10895           declarator = TREE_OPERAND (declarator, 0);
10896           break;
10897
10898         case RECORD_TYPE:
10899         case UNION_TYPE:
10900         case ENUMERAL_TYPE:
10901           declarator = NULL_TREE;
10902           break;
10903
10904         case ERROR_MARK:
10905           declarator = NULL_TREE;
10906           break;
10907
10908         default:
10909           my_friendly_abort (158);
10910         }
10911     }
10912
10913   /* See the comment for the TREE_LIST case, above.  */
10914   if (inner_attrs)
10915     {
10916       if (! ignore_attrs)
10917         decl_attributes (type, inner_attrs, NULL_TREE);
10918       else if (attrlist)
10919         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10920       else
10921         attrlist = build_tree_list (NULL_TREE, inner_attrs);
10922     }
10923
10924   /* Now TYPE has the actual type.  */
10925
10926   if (explicitp == 1 || (explicitp && friendp))
10927     {
10928       /* [dcl.fct.spec] The explicit specifier shall only be used in
10929          declarations of constructors within a class definition.  */
10930       error ("only declarations of constructors can be `explicit'");
10931       explicitp = 0;
10932     }
10933
10934   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10935     {
10936       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10937         {
10938           error ("non-member `%s' cannot be declared `mutable'", name);
10939           RIDBIT_RESET (RID_MUTABLE, specbits);
10940         }
10941       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10942         {
10943           error ("non-object member `%s' cannot be declared `mutable'", name);
10944           RIDBIT_RESET (RID_MUTABLE, specbits);
10945         }
10946       else if (TREE_CODE (type) == FUNCTION_TYPE
10947                || TREE_CODE (type) == METHOD_TYPE)
10948         {
10949           error ("function `%s' cannot be declared `mutable'", name);
10950           RIDBIT_RESET (RID_MUTABLE, specbits);
10951         }
10952       else if (staticp)
10953         {
10954           error ("static `%s' cannot be declared `mutable'", name);
10955           RIDBIT_RESET (RID_MUTABLE, specbits);
10956         }
10957       else if (type_quals & TYPE_QUAL_CONST)
10958         {
10959           error ("const `%s' cannot be declared `mutable'", name);
10960           RIDBIT_RESET (RID_MUTABLE, specbits);
10961         }
10962     }
10963
10964   if (declarator == NULL_TREE
10965       || TREE_CODE (declarator) == IDENTIFIER_NODE
10966       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10967           && (TREE_CODE (type) == FUNCTION_TYPE
10968               || TREE_CODE (type) == METHOD_TYPE)))
10969     /* OK */;
10970   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10971     {
10972       cp_error ("template-id `%D' used as a declarator", declarator);
10973       declarator = dname;
10974     }
10975   else
10976     /* Unexpected declarator format.  */
10977     my_friendly_abort (990210);
10978
10979   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10980
10981   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10982     {
10983       tree decl;
10984
10985       /* Note that the grammar rejects storage classes
10986          in typenames, fields or parameters.  */
10987       if (current_lang_name == lang_name_java)
10988         TYPE_FOR_JAVA (type) = 1;
10989
10990       if (decl_context == FIELD)
10991         {
10992           if (declarator == constructor_name (current_class_type))
10993             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10994                         declarator);
10995           decl = build_lang_decl (TYPE_DECL, declarator, type);
10996         }
10997       else
10998         decl = build_decl (TYPE_DECL, declarator, type);
10999
11000       /* If the user declares "typedef struct {...} foo" then the
11001          struct will have an anonymous name.  Fill that name in now.
11002          Nothing can refer to it, so nothing needs know about the name
11003          change.  */
11004       if (type != error_mark_node
11005           && declarator
11006           && TYPE_NAME (type)
11007           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11008           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11009           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11010         {
11011           tree oldname = TYPE_NAME (type);
11012           tree t;
11013
11014           /* Replace the anonymous name with the real name everywhere.  */
11015           lookup_tag_reverse (type, declarator);
11016           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11017             if (TYPE_NAME (t) == oldname)
11018               TYPE_NAME (t) = decl;
11019
11020           if (TYPE_LANG_SPECIFIC (type))
11021             TYPE_WAS_ANONYMOUS (type) = 1;
11022
11023           /* If this is a typedef within a template class, the nested
11024              type is a (non-primary) template.  The name for the
11025              template needs updating as well.  */
11026           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11027             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11028               = TYPE_IDENTIFIER (type);
11029
11030           if (flag_new_abi)
11031             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11032           else
11033             {
11034               /* XXX Temporarily set the scope.
11035                  When returning, start_decl expects it as NULL_TREE,
11036                  and will then then set it using pushdecl. */
11037               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11038               if (current_class_type)
11039                 DECL_CONTEXT (decl) = current_class_type;
11040               else
11041                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11042
11043               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11044               DECL_ASSEMBLER_NAME (decl)
11045                 = get_identifier (build_overload_name (type, 1, 1));
11046               DECL_CONTEXT (decl) = NULL_TREE;
11047             }
11048
11049           /* FIXME remangle member functions; member functions of a
11050              type with external linkage have external linkage.  */
11051         }
11052
11053       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11054         {
11055           cp_error_at ("typedef name may not be class-qualified", decl);
11056           return NULL_TREE;
11057         }
11058       else if (quals)
11059         {
11060           if (ctype == NULL_TREE)
11061             {
11062               if (TREE_CODE (type) != METHOD_TYPE)
11063                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11064               else
11065                 ctype = TYPE_METHOD_BASETYPE (type);
11066             }
11067           if (ctype != NULL_TREE)
11068             grok_method_quals (ctype, decl, quals);
11069         }
11070
11071       if (RIDBIT_SETP (RID_SIGNED, specbits)
11072           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11073         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11074
11075       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11076                       inlinep, friendp, raises != NULL_TREE);
11077
11078       if (initialized)
11079         error ("typedef declaration includes an initializer");
11080
11081       return decl;
11082     }
11083
11084   /* Detect the case of an array type of unspecified size
11085      which came, as such, direct from a typedef name.
11086      We must copy the type, so that each identifier gets
11087      a distinct type, so that each identifier's size can be
11088      controlled separately by its own initializer.  */
11089
11090   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11091       && TYPE_DOMAIN (type) == NULL_TREE)
11092     {
11093       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11094     }
11095
11096   /* If this is a type name (such as, in a cast or sizeof),
11097      compute the type and return it now.  */
11098
11099   if (decl_context == TYPENAME)
11100     {
11101       /* Note that the grammar rejects storage classes
11102          in typenames, fields or parameters.  */
11103       if (type_quals != TYPE_UNQUALIFIED)
11104         type_quals = TYPE_UNQUALIFIED;
11105
11106       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11107       if (friendp)
11108         {
11109           if (type_quals != TYPE_UNQUALIFIED)
11110             {
11111               cp_error ("type qualifiers specified for friend class declaration");
11112               type_quals = TYPE_UNQUALIFIED;
11113             }
11114           if (inlinep)
11115             {
11116               cp_error ("`inline' specified for friend class declaration");
11117               inlinep = 0;
11118             }
11119
11120           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11121              But don't allow implicit typenames except with a class-key.  */
11122           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11123                                 || IMPLICIT_TYPENAME_P (type)))
11124             {
11125               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11126                 cp_pedwarn ("template parameters cannot be friends");
11127               else if (TREE_CODE (type) == TYPENAME_TYPE)
11128                 cp_pedwarn ("\
11129 friend declaration requires class-key, i.e. `friend class %T::%T'",
11130                             constructor_name (current_class_type),
11131                             TYPE_IDENTIFIER (type));
11132               else
11133                 cp_pedwarn ("\
11134 friend declaration requires class-key, i.e. `friend %#T'",
11135                             type);
11136             }
11137
11138           /* Only try to do this stuff if we didn't already give up.  */
11139           if (type != integer_type_node)
11140             {
11141               decl_type_access_control (TYPE_NAME (type));
11142
11143               /* A friendly class?  */
11144               if (current_class_type)
11145                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11146               else
11147                 cp_error ("trying to make class `%T' a friend of global scope",
11148                           type);
11149
11150               type = void_type_node;
11151             }
11152         }
11153       else if (quals)
11154         {
11155           if (ctype == NULL_TREE)
11156             {
11157               if (TREE_CODE (type) != METHOD_TYPE)
11158                 cp_error ("invalid qualifiers on non-member function type");
11159               else
11160                 ctype = TYPE_METHOD_BASETYPE (type);
11161             }
11162           if (ctype)
11163             {
11164               tree dummy = build_decl (TYPE_DECL, declarator, type);
11165               grok_method_quals (ctype, dummy, quals);
11166               type = TREE_TYPE (dummy);
11167             }
11168         }
11169
11170       return type;
11171     }
11172   else if (declarator == NULL_TREE && decl_context != PARM
11173            && decl_context != CATCHPARM
11174            && TREE_CODE (type) != UNION_TYPE
11175            && ! bitfield)
11176     {
11177       cp_error ("abstract declarator `%T' used as declaration", type);
11178       declarator = make_anon_name ();
11179     }
11180
11181   /* `void' at top level (not within pointer)
11182      is allowed only in typedefs or type names.
11183      We don't complain about parms either, but that is because
11184      a better error message can be made later.  */
11185
11186   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11187     {
11188       if (! declarator)
11189         error ("unnamed variable or field declared void");
11190       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11191         {
11192           if (IDENTIFIER_OPNAME_P (declarator))
11193             my_friendly_abort (356);
11194           else
11195             error ("variable or field `%s' declared void", name);
11196         }
11197       else
11198         error ("variable or field declared void");
11199       type = integer_type_node;
11200     }
11201
11202   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11203      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11204
11205   if (decl_context == PARM || decl_context == CATCHPARM)
11206     {
11207       if (ctype || in_namespace)
11208         error ("cannot use `::' in parameter declaration");
11209
11210       /* A parameter declared as an array of T is really a pointer to T.
11211          One declared as a function is really a pointer to a function.
11212          One declared as a member is really a pointer to member.  */
11213
11214       if (TREE_CODE (type) == ARRAY_TYPE)
11215         {
11216           /* Transfer const-ness of array into that of type pointed to.  */
11217           type = build_pointer_type (TREE_TYPE (type));
11218           type_quals = TYPE_UNQUALIFIED;
11219         }
11220       else if (TREE_CODE (type) == FUNCTION_TYPE)
11221         type = build_pointer_type (type);
11222       else if (TREE_CODE (type) == OFFSET_TYPE)
11223         type = build_pointer_type (type);
11224     }
11225
11226   {
11227     register tree decl;
11228
11229     if (decl_context == PARM)
11230       {
11231         decl = build_decl (PARM_DECL, declarator, type);
11232
11233         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11234                         inlinep, friendp, raises != NULL_TREE);
11235
11236         /* Compute the type actually passed in the parmlist,
11237            for the case where there is no prototype.
11238            (For example, shorts and chars are passed as ints.)
11239            When there is a prototype, this is overridden later.  */
11240
11241         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11242       }
11243     else if (decl_context == FIELD)
11244       {
11245         if (type == error_mark_node)
11246           {
11247             /* Happens when declaring arrays of sizes which
11248                are error_mark_node, for example.  */
11249             decl = NULL_TREE;
11250           }
11251         else if (in_namespace && !friendp)
11252           {
11253             /* Something like struct S { int N::j; };  */
11254             cp_error ("invalid use of `::'");
11255             decl = NULL_TREE;
11256           }
11257         else if (TREE_CODE (type) == FUNCTION_TYPE)
11258           {
11259             int publicp = 0;
11260             tree function_context;
11261
11262             /* We catch the others as conflicts with the builtin
11263                typedefs.  */
11264             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11265               {
11266                 cp_error ("function `%D' cannot be declared friend",
11267                           declarator);
11268                 friendp = 0;
11269               }
11270
11271             if (friendp == 0)
11272               {
11273                 if (ctype == NULL_TREE)
11274                   ctype = current_class_type;
11275
11276                 if (ctype == NULL_TREE)
11277                   {
11278                     cp_error ("can't make `%D' into a method -- not in a class",
11279                               declarator);
11280                     return void_type_node;
11281                   }
11282
11283                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11284                    ARM 9.5 */
11285                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11286                   {
11287                     cp_error ("function `%D' declared virtual inside a union",
11288                               declarator);
11289                     return void_type_node;
11290                   }
11291
11292                 if (declarator == ansi_opname (NEW_EXPR)
11293                     || declarator == ansi_opname (VEC_NEW_EXPR)
11294                     || declarator == ansi_opname (DELETE_EXPR)
11295                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11296                   {
11297                     if (virtualp)
11298                       {
11299                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11300                                   declarator);
11301                         virtualp = 0;
11302                       }
11303                   }
11304                 else if (staticp < 2)
11305                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11306                                                   TYPE_ARG_TYPES (type));
11307               }
11308
11309             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11310             function_context = (ctype != NULL_TREE) ?
11311               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11312             publicp = (! friendp || ! staticp)
11313               && function_context == NULL_TREE;
11314             decl = grokfndecl (ctype, type,
11315                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11316                                ? declarator : dname,
11317                                declarator,
11318                                virtualp, flags, quals, raises,
11319                                friendp ? -1 : 0, friendp, publicp, inlinep,
11320                                funcdef_flag, template_count, in_namespace);
11321             if (decl == NULL_TREE)
11322               return decl;
11323 #if 0
11324             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11325             /* The decl and setting of decl_machine_attr is also turned off.  */
11326             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11327 #endif
11328
11329             /* [class.conv.ctor]
11330
11331                A constructor declared without the function-specifier
11332                explicit that can be called with a single parameter
11333                specifies a conversion from the type of its first
11334                parameter to the type of its class.  Such a constructor
11335                is called a converting constructor.  */
11336             if (explicitp == 2)
11337               DECL_NONCONVERTING_P (decl) = 1;
11338             else if (DECL_CONSTRUCTOR_P (decl))
11339               {
11340                 /* The constructor can be called with exactly one
11341                    parameter if there is at least one parameter, and
11342                    any subsequent parameters have default arguments.
11343                    We don't look at the first parameter, which is
11344                    really just the `this' parameter for the new
11345                    object.  */
11346                 tree arg_types =
11347                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11348
11349                 /* Skip the `in_chrg' argument too, if present.  */
11350                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11351                   arg_types = TREE_CHAIN (arg_types);
11352
11353                 if (arg_types == void_list_node
11354                     || (arg_types
11355                         && TREE_CHAIN (arg_types)
11356                         && TREE_CHAIN (arg_types) != void_list_node
11357                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11358                   DECL_NONCONVERTING_P (decl) = 1;
11359               }
11360           }
11361         else if (TREE_CODE (type) == METHOD_TYPE)
11362           {
11363             /* We only get here for friend declarations of
11364                members of other classes.  */
11365             /* All method decls are public, so tell grokfndecl to set
11366                TREE_PUBLIC, also.  */
11367             decl = grokfndecl (ctype, type, declarator, declarator,
11368                                virtualp, flags, quals, raises,
11369                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11370                                template_count, in_namespace);
11371             if (decl == NULL_TREE)
11372               return NULL_TREE;
11373           }
11374         else if (!staticp && ! processing_template_decl
11375                  && !COMPLETE_TYPE_P (complete_type (type))
11376                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11377           {
11378             if (declarator)
11379               cp_error ("field `%D' has incomplete type", declarator);
11380             else
11381               cp_error ("name `%T' has incomplete type", type);
11382
11383             /* If we're instantiating a template, tell them which
11384                instantiation made the field's type be incomplete.  */
11385             if (current_class_type
11386                 && TYPE_NAME (current_class_type)
11387                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11388                 && declspecs && TREE_VALUE (declspecs)
11389                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11390               cp_error ("  in instantiation of template `%T'",
11391                         current_class_type);
11392
11393             type = error_mark_node;
11394             decl = NULL_TREE;
11395           }
11396         else
11397           {
11398             if (friendp)
11399               {
11400                 error ("`%s' is neither function nor member function; cannot be declared friend",
11401                        IDENTIFIER_POINTER (declarator));
11402                 friendp = 0;
11403               }
11404             decl = NULL_TREE;
11405           }
11406
11407         if (friendp)
11408           {
11409             /* Friends are treated specially.  */
11410             if (ctype == current_class_type)
11411               warning ("member functions are implicitly friends of their class");
11412             else
11413               {
11414                 tree t = NULL_TREE;
11415                 if (decl && DECL_NAME (decl))
11416                   {
11417                     if (template_class_depth (current_class_type) == 0)
11418                       {
11419                         decl
11420                           = check_explicit_specialization
11421                           (declarator, decl,
11422                            template_count, 2 * (funcdef_flag != 0) + 4);
11423                         if (decl == error_mark_node)
11424                           return error_mark_node;
11425                       }
11426
11427                     t = do_friend (ctype, declarator, decl,
11428                                    last_function_parms, attrlist, flags, quals,
11429                                    funcdef_flag);
11430                   }
11431                 if (t && funcdef_flag)
11432                   return t;
11433
11434                 return void_type_node;
11435               }
11436           }
11437
11438         /* Structure field.  It may not be a function, except for C++ */
11439
11440         if (decl == NULL_TREE)
11441           {
11442             if (initialized)
11443               {
11444                 if (!staticp)
11445                   {
11446                     /* An attempt is being made to initialize a non-static
11447                        member.  But, from [class.mem]:
11448
11449                        4 A member-declarator can contain a
11450                        constant-initializer only if it declares a static
11451                        member (_class.static_) of integral or enumeration
11452                        type, see _class.static.data_.
11453
11454                        This used to be relatively common practice, but
11455                        the rest of the compiler does not correctly
11456                        handle the initialization unless the member is
11457                        static so we make it static below.  */
11458                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11459                                 declarator);
11460                     cp_pedwarn ("making `%D' static", declarator);
11461                     staticp = 1;
11462                   }
11463
11464                 if (uses_template_parms (type))
11465                   /* We'll check at instantiation time.  */
11466                   ;
11467                 else if (check_static_variable_definition (declarator,
11468                                                            type))
11469                   /* If we just return the declaration, crashes
11470                      will sometimes occur.  We therefore return
11471                      void_type_node, as if this was a friend
11472                      declaration, to cause callers to completely
11473                      ignore this declaration.  */
11474                   return void_type_node;
11475               }
11476
11477             /* 9.2p13 [class.mem] */
11478             if (declarator == constructor_name (current_class_type)
11479                 /* The standard does not allow non-static data members
11480                    here either, but we agreed at the 10/99 meeting
11481                    to change that in TC 1 so that they are allowed in
11482                    classes with no user-defined constructors.  */
11483                 && staticp)
11484               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11485                           declarator);
11486
11487             if (staticp)
11488               {
11489                 /* C++ allows static class members.  All other work
11490                    for this is done by grokfield.  */
11491                 decl = build_lang_decl (VAR_DECL, declarator, type);
11492                 TREE_STATIC (decl) = 1;
11493                 /* In class context, 'static' means public access.  */
11494                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11495               }
11496             else
11497               {
11498                 decl = build_decl (FIELD_DECL, declarator, type);
11499                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11500                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11501                   {
11502                     DECL_MUTABLE_P (decl) = 1;
11503                     RIDBIT_RESET (RID_MUTABLE, specbits);
11504                   }
11505               }
11506
11507             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11508                             inlinep, friendp, raises != NULL_TREE);
11509           }
11510       }
11511     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11512       {
11513         tree original_name;
11514         int publicp = 0;
11515
11516         if (! declarator)
11517           return NULL_TREE;
11518
11519         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11520           original_name = dname;
11521         else
11522           original_name = declarator;
11523
11524         if (RIDBIT_SETP (RID_AUTO, specbits))
11525           error ("storage class `auto' invalid for function `%s'", name);
11526         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11527           error ("storage class `register' invalid for function `%s'", name);
11528
11529         /* Function declaration not at top level.
11530            Storage classes other than `extern' are not allowed
11531            and `extern' makes no difference.  */
11532         if (! toplevel_bindings_p ()
11533             && (RIDBIT_SETP (RID_STATIC, specbits)
11534                 || RIDBIT_SETP (RID_INLINE, specbits))
11535             && pedantic)
11536           {
11537             if (RIDBIT_SETP (RID_STATIC, specbits))
11538               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11539             else
11540               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11541           }
11542
11543         if (ctype == NULL_TREE)
11544           {
11545             if (virtualp)
11546               {
11547                 error ("virtual non-class function `%s'", name);
11548                 virtualp = 0;
11549               }
11550           }
11551         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11552           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11553                                           TYPE_ARG_TYPES (type));
11554
11555         /* Record presence of `static'.  */
11556         publicp = (ctype != NULL_TREE
11557                    || RIDBIT_SETP (RID_EXTERN, specbits)
11558                    || !RIDBIT_SETP (RID_STATIC, specbits));
11559
11560         decl = grokfndecl (ctype, type, original_name, declarator,
11561                            virtualp, flags, quals, raises,
11562                            1, friendp,
11563                            publicp, inlinep, funcdef_flag,
11564                            template_count, in_namespace);
11565         if (decl == NULL_TREE)
11566           return NULL_TREE;
11567
11568         if (staticp == 1)
11569           {
11570             int illegal_static = 0;
11571
11572             /* Don't allow a static member function in a class, and forbid
11573                declaring main to be static.  */
11574             if (TREE_CODE (type) == METHOD_TYPE)
11575               {
11576                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11577                 illegal_static = 1;
11578               }
11579             else if (current_function_decl)
11580               {
11581                 /* FIXME need arm citation */
11582                 error ("cannot declare static function inside another function");
11583                 illegal_static = 1;
11584               }
11585
11586             if (illegal_static)
11587               {
11588                 staticp = 0;
11589                 RIDBIT_RESET (RID_STATIC, specbits);
11590               }
11591           }
11592       }
11593     else
11594       {
11595         /* It's a variable.  */
11596
11597         /* An uninitialized decl with `extern' is a reference.  */
11598         decl = grokvardecl (type, declarator, &specbits,
11599                             initialized,
11600                             (type_quals & TYPE_QUAL_CONST) != 0,
11601                             in_namespace);
11602         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11603                         inlinep, friendp, raises != NULL_TREE);
11604
11605         if (ctype)
11606           {
11607             DECL_CONTEXT (decl) = ctype;
11608             if (staticp == 1)
11609               {
11610                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11611                 staticp = 0;
11612                 RIDBIT_RESET (RID_STATIC, specbits);
11613               }
11614             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11615               {
11616                 cp_error ("static member `%D' declared `register'", decl);
11617                 RIDBIT_RESET (RID_REGISTER, specbits);
11618               }
11619             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11620               {
11621                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11622                             decl);
11623                 RIDBIT_RESET (RID_EXTERN, specbits);
11624               }
11625           }
11626       }
11627
11628     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11629
11630     /* Record `register' declaration for warnings on &
11631        and in case doing stupid register allocation.  */
11632
11633     if (RIDBIT_SETP (RID_REGISTER, specbits))
11634       DECL_REGISTER (decl) = 1;
11635
11636     if (RIDBIT_SETP (RID_EXTERN, specbits))
11637       DECL_THIS_EXTERN (decl) = 1;
11638
11639     if (RIDBIT_SETP (RID_STATIC, specbits))
11640       DECL_THIS_STATIC (decl) = 1;
11641
11642     /* Record constancy and volatility.  There's no need to do this
11643        when processing a template; we'll do this for the instantiated
11644        declaration based on the type of DECL.  */
11645     if (!processing_template_decl)
11646       c_apply_type_quals_to_decl (type_quals, decl);
11647
11648     return decl;
11649   }
11650 }
11651 \f
11652 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11653    An empty exprlist is a parmlist.  An exprlist which
11654    contains only identifiers at the global level
11655    is a parmlist.  Otherwise, it is an exprlist.  */
11656
11657 int
11658 parmlist_is_exprlist (exprs)
11659      tree exprs;
11660 {
11661   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11662     return 0;
11663
11664   if (toplevel_bindings_p ())
11665     {
11666       /* At the global level, if these are all identifiers,
11667          then it is a parmlist.  */
11668       while (exprs)
11669         {
11670           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11671             return 1;
11672           exprs = TREE_CHAIN (exprs);
11673         }
11674       return 0;
11675     }
11676   return 1;
11677 }
11678
11679 /* Subroutine of start_function.  Ensure that each of the parameter
11680    types (as listed in PARMS) is complete, as is required for a
11681    function definition.  */
11682
11683 static void
11684 require_complete_types_for_parms (parms)
11685      tree parms;
11686 {
11687   for (; parms; parms = TREE_CHAIN (parms))
11688     {
11689       if (VOID_TYPE_P (TREE_TYPE (parms)))
11690         /* grokparms will have already issued an error */
11691         TREE_TYPE (parms) = error_mark_node;
11692       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11693         layout_decl (parms, 0);
11694       else
11695         TREE_TYPE (parms) = error_mark_node;
11696     }
11697 }
11698
11699 /* Returns non-zero if T is a local variable.  */
11700
11701 int
11702 local_variable_p (t)
11703      tree t;
11704 {
11705   if ((TREE_CODE (t) == VAR_DECL
11706        /* A VAR_DECL with a context that is a _TYPE is a static data
11707           member.  */
11708        && !TYPE_P (CP_DECL_CONTEXT (t))
11709        /* Any other non-local variable must be at namespace scope.  */
11710        && !DECL_NAMESPACE_SCOPE_P (t))
11711       || (TREE_CODE (t) == PARM_DECL))
11712     return 1;
11713
11714   return 0;
11715 }
11716
11717 /* Returns non-zero if T is an automatic local variable or a label.
11718    (These are the declarations that need to be remapped when the code
11719    containing them is duplicated.)  */
11720
11721 int
11722 nonstatic_local_decl_p (t)
11723      tree t;
11724 {
11725   return ((local_variable_p (t) && !TREE_STATIC (t))
11726           || TREE_CODE (t) == LABEL_DECL
11727           || TREE_CODE (t) == RESULT_DECL);
11728 }
11729
11730 /* Like local_variable_p, but suitable for use as a tree-walking
11731    function.  */
11732
11733 static tree
11734 local_variable_p_walkfn (tp, walk_subtrees, data)
11735      tree *tp;
11736      int *walk_subtrees ATTRIBUTE_UNUSED;
11737      void *data ATTRIBUTE_UNUSED;
11738 {
11739   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11740           ? *tp : NULL_TREE);
11741 }
11742
11743 /* Check that ARG, which is a default-argument expression for a
11744    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11745    something goes wrong.  DECL may also be a _TYPE node, rather than a
11746    DECL, if there is no DECL available.  */
11747
11748 tree
11749 check_default_argument (decl, arg)
11750      tree decl;
11751      tree arg;
11752 {
11753   tree var;
11754   tree decl_type;
11755
11756   if (TREE_CODE (arg) == DEFAULT_ARG)
11757     /* We get a DEFAULT_ARG when looking at an in-class declaration
11758        with a default argument.  Ignore the argument for now; we'll
11759        deal with it after the class is complete.  */
11760     return arg;
11761
11762   if (processing_template_decl || uses_template_parms (arg))
11763     /* We don't do anything checking until instantiation-time.  Note
11764        that there may be uninstantiated arguments even for an
11765        instantiated function, since default arguments are not
11766        instantiated until they are needed.  */
11767     return arg;
11768
11769   if (TYPE_P (decl))
11770     {
11771       decl_type = decl;
11772       decl = NULL_TREE;
11773     }
11774   else
11775     decl_type = TREE_TYPE (decl);
11776
11777   if (arg == error_mark_node
11778       || decl == error_mark_node
11779       || TREE_TYPE (arg) == error_mark_node
11780       || decl_type == error_mark_node)
11781     /* Something already went wrong.  There's no need to check
11782        further.  */
11783     return error_mark_node;
11784
11785   /* [dcl.fct.default]
11786
11787      A default argument expression is implicitly converted to the
11788      parameter type.  */
11789   if (!TREE_TYPE (arg)
11790       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11791     {
11792       if (decl)
11793         cp_error ("default argument for `%#D' has type `%T'",
11794                   decl, TREE_TYPE (arg));
11795       else
11796         cp_error ("default argument for parameter of type `%T' has type `%T'",
11797                   decl_type, TREE_TYPE (arg));
11798
11799       return error_mark_node;
11800     }
11801
11802   /* [dcl.fct.default]
11803
11804      Local variables shall not be used in default argument
11805      expressions.
11806
11807      The keyword `this' shall not be used in a default argument of a
11808      member function.  */
11809   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11810                                       NULL);
11811   if (var)
11812     {
11813       cp_error ("default argument `%E' uses local variable `%D'",
11814                 arg, var);
11815       return error_mark_node;
11816     }
11817
11818   /* All is well.  */
11819   return arg;
11820 }
11821
11822 /* Decode the list of parameter types for a function type.
11823    Given the list of things declared inside the parens,
11824    return a list of types.
11825
11826    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11827    flag. If unset, we append void_list_node. A parmlist declared
11828    as `(void)' is accepted as the empty parmlist.
11829
11830    Also set last_function_parms to the chain of PARM_DECLs.  */
11831
11832 static tree
11833 grokparms (first_parm)
11834      tree first_parm;
11835 {
11836   tree result = NULL_TREE;
11837   tree decls = NULL_TREE;
11838   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11839   tree parm, chain;
11840   int any_error = 0;
11841
11842   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11843
11844   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11845     {
11846       tree type = NULL_TREE;
11847       register tree decl = TREE_VALUE (parm);
11848       tree init = TREE_PURPOSE (parm);
11849
11850       chain = TREE_CHAIN (parm);
11851       /* @@ weak defense against parse errors.  */
11852       if (TREE_CODE (decl) != VOID_TYPE
11853           && TREE_CODE (decl) != TREE_LIST)
11854         {
11855           /* Give various messages as the need arises.  */
11856           if (TREE_CODE (decl) == STRING_CST)
11857             cp_error ("invalid string constant `%E'", decl);
11858           else if (TREE_CODE (decl) == INTEGER_CST)
11859             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11860           continue;
11861         }
11862
11863       if (parm == void_list_node)
11864         break;
11865
11866       decl = grokdeclarator (TREE_VALUE (decl), TREE_PURPOSE (decl),
11867                      PARM, init != NULL_TREE, NULL_TREE);
11868       if (! decl || TREE_TYPE (decl) == error_mark_node)
11869         continue;
11870
11871       type = TREE_TYPE (decl);
11872       if (VOID_TYPE_P (type))
11873         {
11874           if (same_type_p (type, void_type_node)
11875               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
11876             /* this is a parmlist of `(void)', which is ok.  */
11877             break;
11878           incomplete_type_error (decl, type);
11879           /* It's not a good idea to actually create parameters of
11880              type `void'; other parts of the compiler assume that a
11881              void type terminates the parameter list.  */
11882           type = error_mark_node;
11883           TREE_TYPE (decl) = error_mark_node;
11884         }
11885
11886       if (type != error_mark_node)
11887         {
11888           /* Top-level qualifiers on the parameters are
11889              ignored for function types.  */
11890           type = TYPE_MAIN_VARIANT (type);
11891           if (TREE_CODE (type) == METHOD_TYPE)
11892             {
11893               cp_error ("parameter `%D' invalidly declared method type", decl);
11894               type = build_pointer_type (type);
11895               TREE_TYPE (decl) = type;
11896             }
11897           else if (TREE_CODE (type) == OFFSET_TYPE)
11898             {
11899               cp_error ("parameter `%D' invalidly declared offset type", decl);
11900               type = build_pointer_type (type);
11901               TREE_TYPE (decl) = type;
11902             }
11903           else if (abstract_virtuals_error (decl, type))
11904             any_error = 1;  /* Seems like a good idea. */
11905           else if (POINTER_TYPE_P (type))
11906             {
11907               /* [dcl.fct]/6, parameter types cannot contain pointers
11908                  (references) to arrays of unknown bound.  */
11909               tree t = TREE_TYPE (type);
11910               int ptr = TYPE_PTR_P (type);
11911
11912               while (1)
11913                 {
11914                   if (TYPE_PTR_P (t))
11915                     ptr = 1;
11916                   else if (TREE_CODE (t) != ARRAY_TYPE)
11917                     break;
11918                   else if (!TYPE_DOMAIN (t))
11919                     break;
11920                   t = TREE_TYPE (t);
11921                 }
11922               if (TREE_CODE (t) == ARRAY_TYPE)
11923                 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
11924                           decl, ptr ? "pointer" : "reference", t);
11925             }
11926
11927           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11928           if (PROMOTE_PROTOTYPES
11929               && (TREE_CODE (type) == INTEGER_TYPE
11930                   || TREE_CODE (type) == ENUMERAL_TYPE)
11931               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11932             DECL_ARG_TYPE (decl) = integer_type_node;
11933           if (!any_error && init)
11934             init = check_default_argument (decl, init);
11935           else
11936             init = NULL_TREE;
11937         }
11938
11939       TREE_CHAIN (decl) = decls;
11940       decls = decl;
11941       result = tree_cons (init, type, result);
11942     }
11943   decls = nreverse (decls);
11944   result = nreverse (result);
11945   if (!ellipsis)
11946     result = chainon (result, void_list_node);
11947   last_function_parms = decls;
11948
11949   return result;
11950 }
11951
11952 \f
11953 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11954    D's arguments allow it to be a copy constructor, or copy assignment
11955    operator.  */
11956
11957 int
11958 copy_args_p (d)
11959      tree d;
11960 {
11961   tree t;
11962
11963   if (!DECL_FUNCTION_MEMBER_P (d))
11964     return 0;
11965
11966   t = FUNCTION_ARG_CHAIN (d);
11967   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
11968     t = TREE_CHAIN (t);
11969   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11970       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11971           == DECL_CONTEXT (d))
11972       && (TREE_CHAIN (t) == NULL_TREE
11973           || TREE_CHAIN (t) == void_list_node
11974           || TREE_PURPOSE (TREE_CHAIN (t))))
11975     return 1;
11976   return 0;
11977 }
11978
11979 /* These memoizing functions keep track of special properties which
11980    a class may have.  `grok_ctor_properties' notices whether a class
11981    has a constructor of the form X(X&), and also complains
11982    if the class has a constructor of the form X(X).
11983    `grok_op_properties' takes notice of the various forms of
11984    operator= which are defined, as well as what sorts of type conversion
11985    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11986
11987 int
11988 grok_ctor_properties (ctype, decl)
11989      tree ctype, decl;
11990 {
11991   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11992   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11993
11994   /* When a type has virtual baseclasses, a magical first int argument is
11995      added to any ctor so we can tell if the class has been initialized
11996      yet.  This could screw things up in this function, so we deliberately
11997      ignore the leading int if we're in that situation.  */
11998   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11999     {
12000       my_friendly_assert (parmtypes
12001                           && TREE_VALUE (parmtypes) == integer_type_node,
12002                           980529);
12003       parmtypes = TREE_CHAIN (parmtypes);
12004       parmtype = TREE_VALUE (parmtypes);
12005     }
12006
12007   /* [class.copy]
12008
12009      A non-template constructor for class X is a copy constructor if
12010      its first parameter is of type X&, const X&, volatile X& or const
12011      volatile X&, and either there are no other parameters or else all
12012      other parameters have default arguments.  */
12013   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12014       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12015       && sufficient_parms_p (TREE_CHAIN (parmtypes))
12016       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12017            && is_member_template (DECL_TI_TEMPLATE (decl))))
12018     {
12019       TYPE_HAS_INIT_REF (ctype) = 1;
12020       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12021         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12022     }
12023   /* [class.copy]
12024
12025      A declaration of a constructor for a class X is ill-formed if its
12026      first parameter is of type (optionally cv-qualified) X and either
12027      there are no other parameters or else all other parameters have
12028      default arguments.
12029
12030      We *don't* complain about member template instantiations that
12031      have this form, though; they can occur as we try to decide what
12032      constructor to use during overload resolution.  Since overload
12033      resolution will never prefer such a constructor to the
12034      non-template copy constructor (which is either explicitly or
12035      implicitly defined), there's no need to worry about their
12036      existence.  Theoretically, they should never even be
12037      instantiated, but that's hard to forestall.  */
12038   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12039            && sufficient_parms_p (TREE_CHAIN (parmtypes))
12040            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12041                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12042     {
12043       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12044                 ctype, ctype);
12045       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12046       return 0;
12047     }
12048   else if (TREE_CODE (parmtype) == VOID_TYPE
12049            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12050     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12051
12052   return 1;
12053 }
12054
12055 /* An operator with this code is unary, but can also be binary.  */
12056
12057 static int
12058 ambi_op_p (code)
12059      enum tree_code code;
12060 {
12061   return (code == INDIRECT_REF
12062           || code == ADDR_EXPR
12063           || code == CONVERT_EXPR
12064           || code == NEGATE_EXPR
12065           || code == PREINCREMENT_EXPR
12066           || code == PREDECREMENT_EXPR);
12067 }
12068
12069 /* An operator with this name can only be unary.  */
12070
12071 static int
12072 unary_op_p (code)
12073      enum tree_code code;
12074 {
12075   return (code == TRUTH_NOT_EXPR
12076           || code == BIT_NOT_EXPR
12077           || code == COMPONENT_REF
12078           || code == TYPE_EXPR);
12079 }
12080
12081 /* Do a little sanity-checking on how they declared their operator.  */
12082
12083 void
12084 grok_op_properties (decl, virtualp, friendp)
12085      tree decl;
12086      int virtualp, friendp;
12087 {
12088   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12089   tree argtype;
12090   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12091   tree name = DECL_NAME (decl);
12092   enum tree_code operator_code;
12093   int arity;
12094
12095   /* Count the number of arguments.  */
12096   for (argtype = argtypes, arity = 0;
12097        argtype && argtype != void_list_node;
12098        argtype = TREE_CHAIN (argtype))
12099     ++arity;
12100
12101   if (current_class_type == NULL_TREE)
12102     friendp = 1;
12103
12104   if (DECL_CONV_FN_P (decl))
12105     operator_code = TYPE_EXPR;
12106   else
12107     do
12108       {
12109 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12110         if (ansi_opname (CODE) == name)                                     \
12111           {                                                                 \
12112             operator_code = CODE;                                           \
12113             break;                                                          \
12114           }                                                                 \
12115         else if (ansi_assopname (CODE) == name)                             \
12116           {                                                                 \
12117             operator_code = CODE;                                           \
12118             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12119             break;                                                          \
12120           }
12121
12122 #include "operators.def"
12123 #undef DEF_OPERATOR
12124
12125         my_friendly_abort (20000527);
12126       }
12127     while (0);
12128   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12129   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12130
12131   if (! friendp)
12132     {
12133       switch (operator_code)
12134         {
12135         case CALL_EXPR:
12136           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12137           break;
12138
12139         case ARRAY_REF:
12140           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12141           break;
12142
12143         case COMPONENT_REF:
12144         case MEMBER_REF:
12145           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12146           break;
12147
12148         case NEW_EXPR:
12149           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12150           break;
12151
12152         case DELETE_EXPR:
12153           TYPE_GETS_DELETE (current_class_type) |= 1;
12154           break;
12155
12156         case VEC_NEW_EXPR:
12157           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12158           break;
12159
12160         case VEC_DELETE_EXPR:
12161           TYPE_GETS_DELETE (current_class_type) |= 2;
12162           break;
12163
12164         default:
12165           break;
12166         }
12167     }
12168
12169   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12170     {
12171       /* When the compiler encounters the definition of A::operator new, it
12172          doesn't look at the class declaration to find out if it's static.  */
12173       if (methodp)
12174         revert_static_member_fn (decl);
12175
12176       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12177     }
12178   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12179     {
12180       if (methodp)
12181         revert_static_member_fn (decl);
12182
12183       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12184     }
12185   else
12186     {
12187       /* An operator function must either be a non-static member function
12188          or have at least one parameter of a class, a reference to a class,
12189          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12190       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12191         {
12192           if (operator_code == TYPE_EXPR
12193               || operator_code == CALL_EXPR
12194               || operator_code == COMPONENT_REF
12195               || operator_code == ARRAY_REF
12196               || operator_code == NOP_EXPR)
12197             cp_error ("`%D' must be a nonstatic member function", decl);
12198           else
12199             {
12200               tree p = argtypes;
12201
12202               if (DECL_STATIC_FUNCTION_P (decl))
12203                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12204
12205               if (p)
12206                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12207                   {
12208                     tree arg = TREE_VALUE (p);
12209                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12210                       arg = TREE_TYPE (arg);
12211
12212                     /* This lets bad template code slip through.  */
12213                     if (IS_AGGR_TYPE (arg)
12214                         || TREE_CODE (arg) == ENUMERAL_TYPE
12215                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12216                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12217                       goto foundaggr;
12218                   }
12219               cp_error
12220                 ("`%D' must have an argument of class or enumerated type",
12221                  decl);
12222             foundaggr:
12223               ;
12224             }
12225         }
12226
12227       if (operator_code == CALL_EXPR)
12228         return;                 /* No restrictions on args. */
12229
12230       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12231         {
12232           tree t = TREE_TYPE (name);
12233           if (! friendp)
12234             {
12235               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12236               const char *what = 0;
12237
12238               if (ref)
12239                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12240
12241               if (TREE_CODE (t) == VOID_TYPE)
12242                 what = "void";
12243               else if (t == current_class_type)
12244                 what = "the same type";
12245               /* Don't force t to be complete here.  */
12246               else if (IS_AGGR_TYPE (t)
12247                        && COMPLETE_TYPE_P (t)
12248                        && DERIVED_FROM_P (t, current_class_type))
12249                 what = "a base class";
12250
12251               if (what)
12252                 warning ("conversion to %s%s will never use a type conversion operator",
12253                          ref ? "a reference to " : "", what);
12254             }
12255         }
12256
12257       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12258           && operator_code == NOP_EXPR)
12259         {
12260           tree parmtype;
12261
12262           if (arity != 2 && methodp)
12263             {
12264               cp_error ("`%D' must take exactly one argument", decl);
12265               return;
12266             }
12267           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12268
12269           /* [class.copy]
12270
12271              A user-declared copy assignment operator X::operator= is
12272              a non-static non-template member function of class X with
12273              exactly one parameter of type X, X&, const X&, volatile
12274              X& or const volatile X&.  */
12275           if (copy_assignment_arg_p (parmtype, virtualp)
12276               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12277                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12278               && ! friendp)
12279             {
12280               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12281               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12282                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12283                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12284             }
12285         }
12286       else if (operator_code == COND_EXPR)
12287         {
12288           /* 13.4.0.3 */
12289           cp_error ("ISO C++ prohibits overloading operator ?:");
12290         }
12291       else if (ambi_op_p (operator_code))
12292         {
12293           if (arity == 1)
12294             /* We pick the one-argument operator codes by default, so
12295                we don't have to change anything.  */
12296             ;
12297           else if (arity == 2)
12298             {
12299               /* If we thought this was a unary operator, we now know
12300                  it to be a binary operator.  */
12301               switch (operator_code)
12302                 {
12303                 case INDIRECT_REF:
12304                   operator_code = MULT_EXPR;
12305                   break;
12306
12307                 case ADDR_EXPR:
12308                   operator_code = BIT_AND_EXPR;
12309                   break;
12310
12311                 case CONVERT_EXPR:
12312                   operator_code = PLUS_EXPR;
12313                   break;
12314
12315                 case NEGATE_EXPR:
12316                   operator_code = MINUS_EXPR;
12317                   break;
12318
12319                 case PREINCREMENT_EXPR:
12320                   operator_code = POSTINCREMENT_EXPR;
12321                   break;
12322
12323                 case PREDECREMENT_EXPR:
12324                   operator_code = POSTDECREMENT_EXPR;
12325                   break;
12326
12327                 default:
12328                   my_friendly_abort (20000527);
12329                 }
12330
12331               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12332
12333               if ((operator_code == POSTINCREMENT_EXPR
12334                    || operator_code == POSTDECREMENT_EXPR)
12335                   && ! processing_template_decl
12336                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12337                 {
12338                   if (methodp)
12339                     cp_error ("postfix `%D' must take `int' as its argument",
12340                               decl);
12341                   else
12342                     cp_error
12343                       ("postfix `%D' must take `int' as its second argument",
12344                        decl);
12345                 }
12346             }
12347           else
12348             {
12349               if (methodp)
12350                 cp_error ("`%D' must take either zero or one argument", decl);
12351               else
12352                 cp_error ("`%D' must take either one or two arguments", decl);
12353             }
12354
12355           /* More Effective C++ rule 6.  */
12356           if (warn_ecpp
12357               && (operator_code == POSTINCREMENT_EXPR
12358                   || operator_code == POSTDECREMENT_EXPR
12359                   || operator_code == PREINCREMENT_EXPR
12360                   || operator_code == PREDECREMENT_EXPR))
12361             {
12362               tree arg = TREE_VALUE (argtypes);
12363               tree ret = TREE_TYPE (TREE_TYPE (decl));
12364               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12365                 arg = TREE_TYPE (arg);
12366               arg = TYPE_MAIN_VARIANT (arg);
12367               if (operator_code == PREINCREMENT_EXPR
12368                   || operator_code == PREDECREMENT_EXPR)
12369                 {
12370                   if (TREE_CODE (ret) != REFERENCE_TYPE
12371                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12372                                        arg))
12373                     cp_warning ("prefix `%D' should return `%T'", decl,
12374                                 build_reference_type (arg));
12375                 }
12376               else
12377                 {
12378                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12379                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12380                 }
12381             }
12382         }
12383       else if (unary_op_p (operator_code))
12384         {
12385           if (arity != 1)
12386             {
12387               if (methodp)
12388                 cp_error ("`%D' must take `void'", decl);
12389               else
12390                 cp_error ("`%D' must take exactly one argument", decl);
12391             }
12392         }
12393       else /* if (binary_op_p (operator_code)) */
12394         {
12395           if (arity != 2)
12396             {
12397               if (methodp)
12398                 cp_error ("`%D' must take exactly one argument", decl);
12399               else
12400                 cp_error ("`%D' must take exactly two arguments", decl);
12401             }
12402
12403           /* More Effective C++ rule 7.  */
12404           if (warn_ecpp
12405               && (operator_code == TRUTH_ANDIF_EXPR
12406                   || operator_code == TRUTH_ORIF_EXPR
12407                   || operator_code == COMPOUND_EXPR))
12408             cp_warning ("user-defined `%D' always evaluates both arguments",
12409                         decl);
12410         }
12411
12412       /* Effective C++ rule 23.  */
12413       if (warn_ecpp
12414           && arity == 2
12415           && (operator_code == PLUS_EXPR
12416               || operator_code == MINUS_EXPR
12417               || operator_code == TRUNC_DIV_EXPR
12418               || operator_code == MULT_EXPR)
12419           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12420         cp_warning ("`%D' should return by value", decl);
12421
12422       /* 13.4.0.8 */
12423       for (; argtypes && argtypes != void_list_node;
12424           argtypes = TREE_CHAIN (argtypes))
12425         if (TREE_PURPOSE (argtypes))
12426           {
12427             TREE_PURPOSE (argtypes) = NULL_TREE;
12428             if (operator_code == POSTINCREMENT_EXPR
12429                 || operator_code == POSTDECREMENT_EXPR)
12430               {
12431                 if (pedantic)
12432                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12433               }
12434             else
12435               cp_error ("`%D' cannot have default arguments", decl);
12436           }
12437
12438     }
12439 }
12440 \f
12441 static const char *
12442 tag_name (code)
12443      enum tag_types code;
12444 {
12445   switch (code)
12446     {
12447     case record_type:
12448       return "struct";
12449     case class_type:
12450       return "class";
12451     case union_type:
12452       return "union ";
12453     case enum_type:
12454       return "enum";
12455     default:
12456       my_friendly_abort (981122);
12457     }
12458 }
12459
12460 /* Get the struct, enum or union (CODE says which) with tag NAME.
12461    Define the tag as a forward-reference if it is not defined.
12462
12463    C++: If a class derivation is given, process it here, and report
12464    an error if multiple derivation declarations are not identical.
12465
12466    If this is a definition, come in through xref_tag and only look in
12467    the current frame for the name (since C++ allows new names in any
12468    scope.)  */
12469
12470 tree
12471 xref_tag (code_type_node, name, globalize)
12472      tree code_type_node;
12473      tree name;
12474      int globalize;
12475 {
12476   enum tag_types tag_code;
12477   enum tree_code code;
12478   register tree ref, t;
12479   struct binding_level *b = current_binding_level;
12480   int got_type = 0;
12481   tree attributes = NULL_TREE;
12482   tree context = NULL_TREE;
12483
12484   /* If we are called from the parser, code_type_node will sometimes be a
12485      TREE_LIST.  This indicates that the user wrote
12486      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12487      use them later.  */
12488   if (TREE_CODE (code_type_node) == TREE_LIST)
12489     {
12490       attributes = TREE_PURPOSE (code_type_node);
12491       code_type_node = TREE_VALUE (code_type_node);
12492     }
12493
12494   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12495   switch (tag_code)
12496     {
12497     case record_type:
12498     case class_type:
12499       code = RECORD_TYPE;
12500       break;
12501     case union_type:
12502       code = UNION_TYPE;
12503       break;
12504     case enum_type:
12505       code = ENUMERAL_TYPE;
12506       break;
12507     default:
12508       my_friendly_abort (18);
12509     }
12510
12511   /* If a cross reference is requested, look up the type
12512      already defined for this tag and return it.  */
12513   if (TYPE_P (name))
12514     {
12515       t = name;
12516       name = TYPE_IDENTIFIER (t);
12517       got_type = 1;
12518     }
12519   else
12520     t = IDENTIFIER_TYPE_VALUE (name);
12521
12522   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12523   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12524     {
12525       static int explained;
12526
12527       cp_warning ("`%s %T' declares a new type at namespace scope;\n\
12528 to refer to the inherited type, say `%s %T::%T'%s",
12529                   tag_name (tag_code), name, tag_name (tag_code),
12530                   constructor_name (current_class_type), TYPE_IDENTIFIER (t),
12531                   (!explained ? "\n\
12532 (names from dependent base classes are not visible to unqualified name lookup)"
12533                    : ""));
12534
12535       explained = 1;
12536     }
12537
12538   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12539       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12540     t = NULL_TREE;
12541
12542   if (! globalize)
12543     {
12544       /* If we know we are defining this tag, only look it up in
12545          this scope and don't try to find it as a type.  */
12546       ref = lookup_tag (code, name, b, 1);
12547     }
12548   else
12549     {
12550       if (t)
12551         {
12552           /* [dcl.type.elab] If the identifier resolves to a
12553              typedef-name or a template type-parameter, the
12554              elaborated-type-specifier is ill-formed.  */
12555           if (t != TYPE_MAIN_VARIANT (t)
12556               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12557             cp_pedwarn ("using typedef-name `%D' after `%s'",
12558                         TYPE_NAME (t), tag_name (tag_code));
12559           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12560             cp_error ("using template type parameter `%T' after `%s'",
12561                       t, tag_name (tag_code));
12562
12563           ref = t;
12564         }
12565       else
12566         ref = lookup_tag (code, name, b, 0);
12567
12568       if (! ref)
12569         {
12570           /* Try finding it as a type declaration.  If that wins,
12571              use it.  */
12572           ref = lookup_name (name, 1);
12573
12574           if (ref != NULL_TREE
12575               && processing_template_decl
12576               && DECL_CLASS_TEMPLATE_P (ref)
12577               && template_class_depth (current_class_type) == 0)
12578             /* Since GLOBALIZE is true, we're declaring a global
12579                template, so we want this type.  */
12580             ref = DECL_TEMPLATE_RESULT (ref);
12581
12582           if (ref && TREE_CODE (ref) == TYPE_DECL
12583               && TREE_CODE (TREE_TYPE (ref)) == code)
12584             ref = TREE_TYPE (ref);
12585           else
12586             ref = NULL_TREE;
12587         }
12588
12589       if (ref && current_class_type
12590           && template_class_depth (current_class_type)
12591           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12592         {
12593           /* Since GLOBALIZE is non-zero, we are not looking at a
12594              definition of this tag.  Since, in addition, we are currently
12595              processing a (member) template declaration of a template
12596              class, we must be very careful; consider:
12597
12598                template <class X>
12599                struct S1
12600
12601                template <class U>
12602                struct S2
12603                { template <class V>
12604                friend struct S1; };
12605
12606              Here, the S2::S1 declaration should not be confused with the
12607              outer declaration.  In particular, the inner version should
12608              have a template parameter of level 2, not level 1.  This
12609              would be particularly important if the member declaration
12610              were instead:
12611
12612                template <class V = U> friend struct S1;
12613
12614              say, when we should tsubst into `U' when instantiating
12615              S2.  On the other hand, when presented with:
12616
12617                  template <class T>
12618                  struct S1 {
12619                    template <class U>
12620                    struct S2 {};
12621                    template <class U>
12622                    friend struct S2;
12623                  };
12624
12625               we must find the inner binding eventually.  We
12626               accomplish this by making sure that the new type we
12627               create to represent this declaration has the right
12628               TYPE_CONTEXT.  */
12629           context = TYPE_CONTEXT (ref);
12630           ref = NULL_TREE;
12631         }
12632     }
12633
12634   if (! ref)
12635     {
12636       /* If no such tag is yet defined, create a forward-reference node
12637          and record it as the "definition".
12638          When a real declaration of this type is found,
12639          the forward-reference will be altered into a real type.  */
12640       if (code == ENUMERAL_TYPE)
12641         {
12642           cp_error ("use of enum `%#D' without previous declaration", name);
12643
12644           ref = make_node (ENUMERAL_TYPE);
12645
12646           /* Give the type a default layout like unsigned int
12647              to avoid crashing if it does not get defined.  */
12648           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12649           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12650           TYPE_USER_ALIGN (ref) = 0;
12651           TREE_UNSIGNED (ref) = 1;
12652           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12653           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12654           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12655
12656           /* Enable us to recognize when a type is created in class context.
12657              To do nested classes correctly, this should probably be cleared
12658              out when we leave this classes scope.  Currently this in only
12659              done in `start_enum'.  */
12660
12661           pushtag (name, ref, globalize);
12662         }
12663       else
12664         {
12665           struct binding_level *old_b = class_binding_level;
12666
12667           ref = make_aggr_type (code);
12668           TYPE_CONTEXT (ref) = context;
12669
12670 #ifdef NONNESTED_CLASSES
12671           /* Class types don't nest the way enums do.  */
12672           class_binding_level = (struct binding_level *)0;
12673 #endif
12674           pushtag (name, ref, globalize);
12675           class_binding_level = old_b;
12676         }
12677     }
12678   else
12679     {
12680       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12681         redeclare_class_template (ref, current_template_parms);
12682     }
12683
12684   /* Until the type is defined, tentatively accept whatever
12685      structure tag the user hands us.  */
12686   if (!COMPLETE_TYPE_P (ref)
12687       && ref != current_class_type
12688       /* Have to check this, in case we have contradictory tag info.  */
12689       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12690     {
12691       if (tag_code == class_type)
12692         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12693       else if (tag_code == record_type)
12694         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12695     }
12696
12697   TREE_TYPE (ref) = attributes;
12698
12699   return ref;
12700 }
12701
12702 tree
12703 xref_tag_from_type (old, id, globalize)
12704      tree old, id;
12705      int globalize;
12706 {
12707   tree code_type_node;
12708
12709   if (TREE_CODE (old) == RECORD_TYPE)
12710     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12711                       ? class_type_node : record_type_node);
12712   else
12713     code_type_node = union_type_node;
12714
12715   if (id == NULL_TREE)
12716     id = TYPE_IDENTIFIER (old);
12717
12718   return xref_tag (code_type_node, id, globalize);
12719 }
12720
12721 /* REF is a type (named NAME), for which we have just seen some
12722    baseclasses.  BINFO is a list of those baseclasses; the
12723    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12724    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12725    struct, or union.  */
12726
12727 void
12728 xref_basetypes (code_type_node, name, ref, binfo)
12729      tree code_type_node;
12730      tree name, ref;
12731      tree binfo;
12732 {
12733   /* In the declaration `A : X, Y, ... Z' we mark all the types
12734      (A, X, Y, ..., Z) so we can check for duplicates.  */
12735   tree binfos;
12736   tree base;
12737
12738   int i, len;
12739   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12740
12741   if (tag_code == union_type)
12742     {
12743       cp_error ("derived union `%T' invalid", ref);
12744       return;
12745     }
12746
12747   len = list_length (binfo);
12748
12749   /* First, make sure that any templates in base-classes are
12750      instantiated.  This ensures that if we call ourselves recursively
12751      we do not get confused about which classes are marked and which
12752      are not.  */
12753   for (base = binfo; base; base = TREE_CHAIN (base))
12754     complete_type (TREE_VALUE (base));
12755
12756   SET_CLASSTYPE_MARKED (ref);
12757   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12758
12759   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12760     {
12761       /* The base of a derived struct is public by default.  */
12762       int via_public
12763         = (TREE_PURPOSE (binfo) == access_public_node
12764            || TREE_PURPOSE (binfo) == access_public_virtual_node
12765            || (tag_code != class_type
12766                && (TREE_PURPOSE (binfo) == access_default_node
12767                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12768       int via_protected
12769         = (TREE_PURPOSE (binfo) == access_protected_node
12770            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12771       int via_virtual
12772         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12773            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12774            || TREE_PURPOSE (binfo) == access_public_virtual_node
12775            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12776       tree basetype = TREE_VALUE (binfo);
12777       tree base_binfo;
12778
12779       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12780         basetype = TREE_TYPE (basetype);
12781       if (!basetype
12782           || (TREE_CODE (basetype) != RECORD_TYPE
12783               && TREE_CODE (basetype) != TYPENAME_TYPE
12784               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12785               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12786         {
12787           cp_error ("base type `%T' fails to be a struct or class type",
12788                     TREE_VALUE (binfo));
12789           continue;
12790         }
12791
12792       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12793
12794       /* This code replaces similar code in layout_basetypes.
12795          We put the complete_type first for implicit `typename'.  */
12796       if (!COMPLETE_TYPE_P (basetype)
12797           && ! (current_template_parms && uses_template_parms (basetype)))
12798         {
12799           cp_error ("base class `%T' has incomplete type", basetype);
12800           continue;
12801         }
12802       else
12803         {
12804           if (CLASSTYPE_MARKED (basetype))
12805             {
12806               if (basetype == ref)
12807                 cp_error ("recursive type `%T' undefined", basetype);
12808               else
12809                 cp_error ("duplicate base type `%T' invalid", basetype);
12810               continue;
12811             }
12812
12813           if (TYPE_FOR_JAVA (basetype)
12814               && (current_lang_stack
12815                   == &VARRAY_TREE (current_lang_base, 0)))
12816             TYPE_FOR_JAVA (ref) = 1;
12817
12818           /* Note that the BINFO records which describe individual
12819              inheritances are *not* shared in the lattice!  They
12820              cannot be shared because a given baseclass may be
12821              inherited with different `accessibility' by different
12822              derived classes.  (Each BINFO record describing an
12823              individual inheritance contains flags which say what
12824              the `accessibility' of that particular inheritance is.)  */
12825
12826           base_binfo
12827             = make_binfo (size_zero_node, basetype,
12828                           CLASS_TYPE_P (basetype)
12829                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12830                           CLASS_TYPE_P (basetype)
12831                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12832
12833           TREE_VEC_ELT (binfos, i) = base_binfo;
12834           TREE_VIA_PUBLIC (base_binfo) = via_public;
12835           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12836           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12837           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12838
12839           /* We need to unshare the binfos now so that lookups during class
12840              definition work.  */
12841           unshare_base_binfos (base_binfo);
12842
12843           SET_CLASSTYPE_MARKED (basetype);
12844
12845           /* We are free to modify these bits because they are meaningless
12846              at top level, and BASETYPE is a top-level type.  */
12847           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12848             {
12849               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12850               /* Converting to a virtual base class requires looking
12851                  up the offset of the virtual base.  */
12852               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12853             }
12854
12855           if (CLASS_TYPE_P (basetype))
12856             {
12857               TYPE_HAS_NEW_OPERATOR (ref)
12858                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12859               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12860                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12861               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12862               /* If the base-class uses multiple inheritance, so do we.  */
12863               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12864                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12865               /* Likewise, if converting to a base of the base may require
12866                  code, then we may need to generate code to convert to a
12867                  base as well.  */
12868               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12869                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12870             }
12871
12872           i += 1;
12873         }
12874     }
12875   if (i)
12876     TREE_VEC_LENGTH (binfos) = i;
12877   else
12878     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12879
12880   if (i > 1)
12881     {
12882       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12883       /* If there is more than one non-empty they cannot be at the same
12884          address.  */
12885       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12886     }
12887
12888   /* Unmark all the types.  */
12889   while (--i >= 0)
12890     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12891   CLEAR_CLASSTYPE_MARKED (ref);
12892
12893   /* Now that we know all the base-classes, set up the list of virtual
12894      bases.  */
12895   get_vbase_types (ref);
12896 }
12897
12898 \f
12899 /* Begin compiling the definition of an enumeration type.
12900    NAME is its name (or null if anonymous).
12901    Returns the type object, as yet incomplete.
12902    Also records info about it so that build_enumerator
12903    may be used to declare the individual values as they are read.  */
12904
12905 tree
12906 start_enum (name)
12907      tree name;
12908 {
12909   register tree enumtype = NULL_TREE;
12910   struct binding_level *b = current_binding_level;
12911
12912   /* If this is the real definition for a previous forward reference,
12913      fill in the contents in the same object that used to be the
12914      forward reference.  */
12915
12916   if (name != NULL_TREE)
12917     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12918
12919   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12920     {
12921       cp_error ("multiple definition of `%#T'", enumtype);
12922       cp_error_at ("previous definition here", enumtype);
12923       /* Clear out TYPE_VALUES, and start again.  */
12924       TYPE_VALUES (enumtype) = NULL_TREE;
12925     }
12926   else
12927     {
12928       enumtype = make_node (ENUMERAL_TYPE);
12929       pushtag (name, enumtype, 0);
12930     }
12931
12932   if (current_class_type)
12933     TREE_ADDRESSABLE (b->tags) = 1;
12934
12935   GNU_xref_decl (current_function_decl, enumtype);
12936   return enumtype;
12937 }
12938
12939 /* After processing and defining all the values of an enumeration type,
12940    install their decls in the enumeration type and finish it off.
12941    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12942    Returns ENUMTYPE.  */
12943
12944 tree
12945 finish_enum (enumtype)
12946      tree enumtype;
12947 {
12948   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12949   /* Calculate the maximum value of any enumerator in this type.  */
12950
12951   tree values = TYPE_VALUES (enumtype);
12952   if (values)
12953     {
12954       tree pair;
12955
12956       for (pair = values; pair; pair = TREE_CHAIN (pair))
12957         {
12958           tree decl;
12959           tree value;
12960
12961           /* The TREE_VALUE is a CONST_DECL for this enumeration
12962              constant.  */
12963           decl = TREE_VALUE (pair);
12964
12965           /* [dcl.enum]
12966
12967              Following the closing brace of an enum-specifier, each
12968              enumerator has the type of its enumeration.  Prior to the
12969              closing brace, the type of each enumerator is the type of
12970              its initializing value.  */
12971           TREE_TYPE (decl) = enumtype;
12972
12973           /* The DECL_INITIAL will be NULL if we are processing a
12974              template declaration and this enumeration constant had no
12975              explicit initializer.  */
12976           value = DECL_INITIAL (decl);
12977           if (value && !processing_template_decl)
12978             {
12979               /* Set the TREE_TYPE for the VALUE as well.  That's so
12980                  that when we call decl_constant_value we get an
12981                  entity of the right type (but with the constant
12982                  value).  Since we shouldn't ever call
12983                  decl_constant_value on a template type, there's no
12984                  reason to do that when processing_template_decl.
12985                  And, if the expression is something like a
12986                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12987                  wreak havoc on the intended type of the expression.
12988
12989                  Of course, there's also no point in trying to compute
12990                  minimum or maximum values if we're in a template.  */
12991               TREE_TYPE (value) = enumtype;
12992
12993               if (!minnode)
12994                 minnode = maxnode = value;
12995               else if (tree_int_cst_lt (maxnode, value))
12996                 maxnode = value;
12997               else if (tree_int_cst_lt (value, minnode))
12998                 minnode = value;
12999             }
13000
13001           if (processing_template_decl)
13002             /* If this is just a template, leave the CONST_DECL
13003                alone.  That way tsubst_copy will find CONST_DECLs for
13004                CONST_DECLs, and not INTEGER_CSTs.  */
13005             ;
13006           else
13007             /* In the list we're building up, we want the enumeration
13008                values, not the CONST_DECLs.  */
13009             TREE_VALUE (pair) = value;
13010         }
13011     }
13012   else
13013     maxnode = minnode = integer_zero_node;
13014
13015   TYPE_VALUES (enumtype) = nreverse (values);
13016
13017   if (processing_template_decl)
13018     {
13019       tree scope = current_scope ();
13020       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13021         add_stmt (build_min (TAG_DEFN, enumtype));
13022     }
13023   else
13024     {
13025       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13026       int lowprec = min_precision (minnode, unsignedp);
13027       int highprec = min_precision (maxnode, unsignedp);
13028       int precision = MAX (lowprec, highprec);
13029       tree tem;
13030
13031       TYPE_SIZE (enumtype) = NULL_TREE;
13032
13033       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13034
13035       TYPE_PRECISION (enumtype) = precision;
13036       if (unsignedp)
13037         fixup_unsigned_type (enumtype);
13038       else
13039         fixup_signed_type (enumtype);
13040
13041       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13042         /* Use the width of the narrowest normal C type which is wide
13043            enough.  */
13044         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13045                                                     (precision, 1));
13046       else
13047         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13048
13049       TYPE_SIZE (enumtype) = 0;
13050       layout_type (enumtype);
13051
13052       /* Fix up all variant types of this enum type.  */
13053       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13054            tem = TYPE_NEXT_VARIANT (tem))
13055         {
13056           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13057           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13058           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13059           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13060           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13061           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13062           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13063           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13064           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13065           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13066         }
13067
13068       /* Finish debugging output for this type.  */
13069       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13070     }
13071
13072   return enumtype;
13073 }
13074
13075 /* Build and install a CONST_DECL for an enumeration constant of the
13076    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13077    Assignment of sequential values by default is handled here.  */
13078
13079 void
13080 build_enumerator (name, value, enumtype)
13081      tree name;
13082      tree value;
13083      tree enumtype;
13084 {
13085   tree decl;
13086   tree context;
13087   tree type;
13088   tree values;
13089
13090   /* Remove no-op casts from the value.  */
13091   if (value)
13092     STRIP_TYPE_NOPS (value);
13093
13094   if (! processing_template_decl)
13095     {
13096       /* Validate and default VALUE.  */
13097       if (value != NULL_TREE)
13098         {
13099           value = decl_constant_value (value);
13100
13101           if (TREE_CODE (value) == INTEGER_CST)
13102             {
13103               value = default_conversion (value);
13104               constant_expression_warning (value);
13105             }
13106           else
13107             {
13108               cp_error ("enumerator value for `%D' not integer constant", name);
13109               value = NULL_TREE;
13110             }
13111         }
13112
13113       /* Default based on previous value.  */
13114       if (value == NULL_TREE && ! processing_template_decl)
13115         {
13116           tree prev_value;
13117
13118           if (TYPE_VALUES (enumtype))
13119             {
13120               /* The next value is the previous value ... */
13121               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13122               /* ... plus one.  */
13123               value = cp_build_binary_op (PLUS_EXPR,
13124                                           prev_value,
13125                                           integer_one_node);
13126
13127               if (tree_int_cst_lt (value, prev_value))
13128                 cp_error ("overflow in enumeration values at `%D'", name);
13129             }
13130           else
13131             value = integer_zero_node;
13132         }
13133
13134       /* Remove no-op casts from the value.  */
13135       if (value)
13136         STRIP_TYPE_NOPS (value);
13137 #if 0
13138       /* To fix MAX_VAL enum consts. (bkoz)  */
13139       TREE_TYPE (value) = integer_type_node;
13140 #endif
13141     }
13142
13143   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13144      Even in other cases, we will later (in finish_enum) be setting
13145      the type of VALUE.  But, we don't need to make a copy if this
13146      VALUE is one of the enumeration constants for this same
13147      enumeration type.  */
13148   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13149     if (TREE_VALUE (values) == value)
13150       break;
13151   /* If we didn't break out of the loop, then we do need a copy.  */
13152   if (!values && value)
13153     value = copy_node (value);
13154
13155   /* C++ associates enums with global, function, or class declarations.  */
13156   context = current_scope ();
13157
13158   /* Build the actual enumeration constant.  Note that the enumeration
13159     constants have the type of their initializers until the
13160     enumeration is complete:
13161
13162       [ dcl.enum ]
13163
13164       Following the closing brace of an enum-specifier, each enumer-
13165       ator has the type of its enumeration.  Prior to the closing
13166       brace, the type of each enumerator is the type of its
13167       initializing value.
13168
13169     In finish_enum we will reset the type.  Of course, if we're
13170     processing a template, there may be no value.   */
13171   type = value ? TREE_TYPE (value) : NULL_TREE;
13172
13173   if (context && context == current_class_type)
13174     /* This enum declaration is local to the class.  We need the full
13175        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13176     decl = build_lang_decl (CONST_DECL, name, type);
13177   else
13178     /* It's a global enum, or it's local to a function.  (Note local to
13179       a function could mean local to a class method.  */
13180     decl = build_decl (CONST_DECL, name, type);
13181
13182   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13183   DECL_INITIAL (decl) = value;
13184   TREE_READONLY (decl) = 1;
13185
13186   if (context && context == current_class_type)
13187     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13188       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13189       things like `S::i' later.)  */
13190     finish_member_declaration (decl);
13191   else
13192     {
13193       pushdecl (decl);
13194       GNU_xref_decl (current_function_decl, decl);
13195     }
13196
13197   /* Add this enumeration constant to the list for this type.  */
13198   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13199 }
13200
13201 \f
13202 /* We're defining DECL.  Make sure that it's type is OK.  */
13203
13204 static void
13205 check_function_type (decl, current_function_parms)
13206      tree decl;
13207      tree current_function_parms;
13208 {
13209   tree fntype = TREE_TYPE (decl);
13210   tree return_type = complete_type (TREE_TYPE (fntype));
13211
13212   /* In a function definition, arg types must be complete.  */
13213   require_complete_types_for_parms (current_function_parms);
13214
13215   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13216     {
13217       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13218
13219       /* Make it return void instead, but don't change the
13220          type of the DECL_RESULT, in case we have a named return value.  */
13221       if (TREE_CODE (fntype) == METHOD_TYPE)
13222         {
13223           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13224           TREE_TYPE (decl)
13225             = build_cplus_method_type (ctype,
13226                                        void_type_node,
13227                                        FUNCTION_ARG_CHAIN (decl));
13228         }
13229       else
13230         TREE_TYPE (decl)
13231           = build_function_type (void_type_node,
13232                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13233       TREE_TYPE (decl)
13234         = build_exception_variant (fntype,
13235                                    TYPE_RAISES_EXCEPTIONS (fntype));
13236     }
13237   else
13238     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13239 }
13240
13241 /* Create the FUNCTION_DECL for a function definition.
13242    DECLSPECS and DECLARATOR are the parts of the declaration;
13243    they describe the function's name and the type it returns,
13244    but twisted together in a fashion that parallels the syntax of C.
13245
13246    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13247    DECLARATOR is really the DECL for the function we are about to
13248    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13249    indicating that the function is an inline defined in-class.
13250
13251    This function creates a binding context for the function body
13252    as well as setting up the FUNCTION_DECL in current_function_decl.
13253
13254    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13255    (it defines a datum instead), we return 0, which tells
13256    yyparse to report a parse error.
13257
13258    For C++, we must first check whether that datum makes any sense.
13259    For example, "class A local_a(1,2);" means that variable local_a
13260    is an aggregate of type A, which should have a constructor
13261    applied to it with the argument list [1, 2].  */
13262
13263 int
13264 start_function (declspecs, declarator, attrs, flags)
13265      tree declspecs, declarator, attrs;
13266      int flags;
13267 {
13268   tree decl1;
13269   tree ctype = NULL_TREE;
13270   tree fntype;
13271   tree restype;
13272   extern int have_extern_spec;
13273   extern int used_extern_spec;
13274   int doing_friend = 0;
13275   struct binding_level *bl;
13276   tree current_function_parms;
13277
13278   /* Sanity check.  */
13279   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13280   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13281
13282   /* This should only be done once on the top most decl.  */
13283   if (have_extern_spec && !used_extern_spec)
13284     {
13285       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13286       used_extern_spec = 1;
13287     }
13288
13289   if (flags & SF_PRE_PARSED)
13290     {
13291       decl1 = declarator;
13292
13293       fntype = TREE_TYPE (decl1);
13294       if (TREE_CODE (fntype) == METHOD_TYPE)
13295         ctype = TYPE_METHOD_BASETYPE (fntype);
13296
13297       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13298          the (lexical) scope of the class in which it is defined.  */
13299       if (!ctype && DECL_FRIEND_P (decl1))
13300         {
13301           ctype = DECL_FRIEND_CONTEXT (decl1);
13302
13303           /* CTYPE could be null here if we're dealing with a template;
13304              for example, `inline friend float foo()' inside a template
13305              will have no CTYPE set.  */
13306           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13307             ctype = NULL_TREE;
13308           else
13309             doing_friend = 1;
13310         }
13311
13312       last_function_parms = DECL_ARGUMENTS (decl1);
13313       last_function_parm_tags = NULL_TREE;
13314     }
13315   else
13316     {
13317       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13318       /* If the declarator is not suitable for a function definition,
13319          cause a syntax error.  */
13320       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13321
13322       fntype = TREE_TYPE (decl1);
13323
13324       restype = TREE_TYPE (fntype);
13325       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13326         {
13327           cp_error ("semicolon missing after declaration of `%#T'", restype);
13328           shadow_tag (build_tree_list (NULL_TREE, restype));
13329           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13330           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13331             fntype = build_function_type (integer_type_node,
13332                                           TYPE_ARG_TYPES (fntype));
13333           else
13334             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13335                                               integer_type_node,
13336                                               TYPE_ARG_TYPES (fntype));
13337           TREE_TYPE (decl1) = fntype;
13338         }
13339
13340       if (TREE_CODE (fntype) == METHOD_TYPE)
13341         ctype = TYPE_METHOD_BASETYPE (fntype);
13342       else if (DECL_MAIN_P (decl1))
13343         {
13344           /* If this doesn't return integer_type, complain.  */
13345           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13346             {
13347               if (pedantic || warn_return_type)
13348                 pedwarn ("return type for `main' changed to `int'");
13349               TREE_TYPE (decl1) = fntype = default_function_type;
13350             }
13351         }
13352     }
13353
13354   /* Sometimes we don't notice that a function is a static member, and
13355      build a METHOD_TYPE for it.  Fix that up now.  */
13356   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13357       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13358     {
13359       revert_static_member_fn (decl1);
13360       last_function_parms = TREE_CHAIN (last_function_parms);
13361       ctype = NULL_TREE;
13362     }
13363
13364   /* Warn if function was previously implicitly declared
13365      (but not if we warned then).  */
13366   if (! warn_implicit
13367       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13368     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13369
13370   /* Set up current_class_type, and enter the scope of the class, if
13371      appropriate.  */
13372   if (ctype)
13373     push_nested_class (ctype, 1);
13374   else if (DECL_STATIC_FUNCTION_P (decl1))
13375     push_nested_class (DECL_CONTEXT (decl1), 2);
13376
13377   /* Now that we have entered the scope of the class, we must restore
13378      the bindings for any template parameters surrounding DECL1, if it
13379      is an inline member template.  (Order is important; consider the
13380      case where a template parameter has the same name as a field of
13381      the class.)  It is not until after this point that
13382      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13383   if (flags & SF_INCLASS_INLINE)
13384     maybe_begin_member_template_processing (decl1);
13385
13386   /* Effective C++ rule 15.  */
13387   if (warn_ecpp
13388       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13389       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13390     cp_warning ("`operator=' should return a reference to `*this'");
13391
13392   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13393      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13394   if (!DECL_INITIAL (decl1))
13395     DECL_INITIAL (decl1) = error_mark_node;
13396
13397 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13398   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13399 #endif
13400
13401   /* This function exists in static storage.
13402      (This does not mean `static' in the C sense!)  */
13403   TREE_STATIC (decl1) = 1;
13404
13405   /* We must call push_template_decl after current_class_type is set
13406      up.  (If we are processing inline definitions after exiting a
13407      class scope, current_class_type will be NULL_TREE until set above
13408      by push_nested_class.)  */
13409   if (processing_template_decl)
13410     decl1 = push_template_decl (decl1);
13411
13412   /* We are now in the scope of the function being defined.  */
13413   current_function_decl = decl1;
13414
13415   /* Save the parm names or decls from this function's declarator
13416      where store_parm_decls will find them.  */
13417   current_function_parms = last_function_parms;
13418   current_function_parm_tags = last_function_parm_tags;
13419
13420   /* Make sure the parameter and return types are reasonable.  When
13421      you declare a function, these types can be incomplete, but they
13422      must be complete when you define the function.  */
13423   if (! processing_template_decl)
13424     check_function_type (decl1, current_function_parms);
13425
13426   /* Build the return declaration for the function.  */
13427   restype = TREE_TYPE (fntype);
13428   if (!processing_template_decl)
13429     {
13430       if (!DECL_RESULT (decl1))
13431         {
13432           DECL_RESULT (decl1)
13433             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13434           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13435                                       DECL_RESULT (decl1));
13436         }
13437     }
13438   else
13439     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13440     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13441
13442   /* Initialize RTL machinery.  We cannot do this until
13443      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13444      even when processing a template; this is how we get
13445      CFUN set up, and our per-function variables initialized.
13446      FIXME factor out the non-RTL stuff.  */
13447   bl = current_binding_level;
13448   init_function_start (decl1, input_filename, lineno);
13449   current_binding_level = bl;
13450
13451   /* Even though we're inside a function body, we still don't want to
13452      call expand_expr to calculate the size of a variable-sized array.
13453      We haven't necessarily assigned RTL to all variables yet, so it's
13454      not safe to try to expand expressions involving them.  */
13455   immediate_size_expand = 0;
13456   cfun->x_dont_save_pending_sizes_p = 1;
13457
13458   /* Start the statement-tree, start the tree now.  */
13459   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13460
13461   /* Let the user know we're compiling this function.  */
13462   announce_function (decl1);
13463
13464   /* Record the decl so that the function name is defined.
13465      If we already have a decl for this name, and it is a FUNCTION_DECL,
13466      use the old decl.  */
13467   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13468     {
13469       /* A specialization is not used to guide overload resolution.  */
13470       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13471           && ! DECL_FUNCTION_MEMBER_P (decl1))
13472         decl1 = pushdecl (decl1);
13473       else
13474         {
13475           /* We need to set the DECL_CONTEXT. */
13476           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13477             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13478           /* And make sure we have enough default args.  */
13479           check_default_args (decl1);
13480         }
13481       fntype = TREE_TYPE (decl1);
13482     }
13483
13484   /* Reset these in case the call to pushdecl changed them.  */
13485   current_function_decl = decl1;
13486   cfun->decl = decl1;
13487
13488   /* If we are (erroneously) defining a function that we have already
13489      defined before, wipe out what we knew before.  */
13490   if (!DECL_PENDING_INLINE_P (decl1)
13491       && DECL_SAVED_FUNCTION_DATA (decl1))
13492     {
13493       free (DECL_SAVED_FUNCTION_DATA (decl1));
13494       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13495     }
13496
13497   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13498     {
13499       /* We know that this was set up by `grokclassfn'.  We do not
13500          wait until `store_parm_decls', since evil parse errors may
13501          never get us to that point.  Here we keep the consistency
13502          between `current_class_type' and `current_class_ptr'.  */
13503       tree t = DECL_ARGUMENTS (decl1);
13504
13505       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13506                           162);
13507       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13508                           19990811);
13509
13510       cp_function_chain->x_current_class_ref
13511         = build_indirect_ref (t, NULL_PTR);
13512       cp_function_chain->x_current_class_ptr = t;
13513
13514       /* Constructors and destructors need to know whether they're "in
13515          charge" of initializing virtual base classes.  */
13516       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13517         current_in_charge_parm = TREE_CHAIN (t);
13518     }
13519
13520   if (DECL_INTERFACE_KNOWN (decl1))
13521     {
13522       tree ctx = decl_function_context (decl1);
13523
13524       if (DECL_NOT_REALLY_EXTERN (decl1))
13525         DECL_EXTERNAL (decl1) = 0;
13526
13527       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13528           && TREE_PUBLIC (ctx))
13529         /* This is a function in a local class in an extern inline
13530            function.  */
13531         comdat_linkage (decl1);
13532     }
13533   /* If this function belongs to an interface, it is public.
13534      If it belongs to someone else's interface, it is also external.
13535      This only affects inlines and template instantiations.  */
13536   else if (interface_unknown == 0
13537            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13538                || flag_alt_external_templates))
13539     {
13540       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13541           || processing_template_decl)
13542         {
13543           DECL_EXTERNAL (decl1)
13544             = (interface_only
13545                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13546                    && !DECL_VINDEX (decl1)));
13547
13548           /* For WIN32 we also want to put these in linkonce sections.  */
13549           maybe_make_one_only (decl1);
13550         }
13551       else
13552         DECL_EXTERNAL (decl1) = 0;
13553       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13554       DECL_INTERFACE_KNOWN (decl1) = 1;
13555     }
13556   else if (interface_unknown && interface_only
13557            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13558                || flag_alt_external_templates))
13559     {
13560       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13561          interface, we will have interface_only set but not
13562          interface_known.  In that case, we don't want to use the normal
13563          heuristics because someone will supply a #pragma implementation
13564          elsewhere, and deducing it here would produce a conflict.  */
13565       comdat_linkage (decl1);
13566       DECL_EXTERNAL (decl1) = 0;
13567       DECL_INTERFACE_KNOWN (decl1) = 1;
13568       DECL_DEFER_OUTPUT (decl1) = 1;
13569     }
13570   else
13571     {
13572       /* This is a definition, not a reference.
13573          So clear DECL_EXTERNAL.  */
13574       DECL_EXTERNAL (decl1) = 0;
13575
13576       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13577           && ! DECL_INTERFACE_KNOWN (decl1)
13578           /* Don't try to defer nested functions for now.  */
13579           && ! decl_function_context (decl1))
13580         DECL_DEFER_OUTPUT (decl1) = 1;
13581       else
13582         DECL_INTERFACE_KNOWN (decl1) = 1;
13583     }
13584
13585   pushlevel (0);
13586   current_binding_level->parm_flag = 1;
13587
13588   if (attrs)
13589     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13590
13591   /* We need to do this even if we aren't expanding yet so that
13592      assemble_external works.  */
13593   make_decl_rtl (decl1, NULL);
13594
13595   /* Promote the value to int before returning it.  */
13596   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13597     restype = type_promotes_to (restype);
13598
13599   /* If this fcn was already referenced via a block-scope `extern' decl
13600      (or an implicit decl), propagate certain information about the usage.  */
13601   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13602     TREE_ADDRESSABLE (decl1) = 1;
13603
13604   if (DECL_RESULT (decl1) == NULL_TREE)
13605     {
13606       DECL_RESULT (decl1)
13607         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13608       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13609       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13610     }
13611
13612   ++function_depth;
13613
13614   if (DECL_DESTRUCTOR_P (decl1))
13615     {
13616       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13617       DECL_CONTEXT (dtor_label) = current_function_decl;
13618     }
13619   /* Under the old ABI we return `this' from constructors, so we make
13620      ordinary `return' statements in constructors jump to CTOR_LABEL;
13621      from there we return `this'.  Under the new ABI, we don't bother
13622      with any of this.  By not setting CTOR_LABEL the remainder of the
13623      machinery is automatically disabled.  */
13624   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13625     {
13626       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13627       DECL_CONTEXT (ctor_label) = current_function_decl;
13628     }
13629
13630   store_parm_decls (current_function_parms);
13631
13632   return 1;
13633 }
13634 \f
13635 /* Store the parameter declarations into the current function declaration.
13636    This is called after parsing the parameter declarations, before
13637    digesting the body of the function.
13638
13639    Also install to binding contour return value identifier, if any.  */
13640
13641 static void
13642 store_parm_decls (current_function_parms)
13643      tree current_function_parms;
13644 {
13645   register tree fndecl = current_function_decl;
13646   register tree parm;
13647   int parms_have_cleanups = 0;
13648   tree cleanups = NULL_TREE;
13649
13650   /* This is a list of types declared among parms in a prototype.  */
13651   tree parmtags = current_function_parm_tags;
13652
13653   /* This is a chain of any other decls that came in among the parm
13654      declarations.  If a parm is declared with  enum {foo, bar} x;
13655      then CONST_DECLs for foo and bar are put here.  */
13656   tree nonparms = NULL_TREE;
13657
13658   if (current_function_parms)
13659     {
13660       /* This case is when the function was defined with an ANSI prototype.
13661          The parms already have decls, so we need not do anything here
13662          except record them as in effect
13663          and complain if any redundant old-style parm decls were written.  */
13664
13665       tree specparms = current_function_parms;
13666       tree next;
13667
13668       /* Must clear this because it might contain TYPE_DECLs declared
13669              at class level.  */
13670       storedecls (NULL_TREE);
13671
13672       /* If we're doing semantic analysis, then we'll call pushdecl
13673              for each of these.  We must do them in reverse order so that
13674              they end in the correct forward order.  */
13675       specparms = nreverse (specparms);
13676
13677       for (parm = specparms; parm; parm = next)
13678         {
13679           next = TREE_CHAIN (parm);
13680           if (TREE_CODE (parm) == PARM_DECL)
13681             {
13682               tree cleanup;
13683
13684               if (DECL_NAME (parm) == NULL_TREE
13685                   || TREE_CODE (parm) != VOID_TYPE)
13686                 pushdecl (parm);
13687               else
13688                 cp_error ("parameter `%D' declared void", parm);
13689
13690               cleanup = (processing_template_decl
13691                          ? NULL_TREE
13692                          : maybe_build_cleanup (parm));
13693
13694               if (cleanup)
13695                 cleanups = tree_cons (parm, cleanup, cleanups);
13696             }
13697           else
13698             {
13699               /* If we find an enum constant or a type tag,
13700                  put it aside for the moment.  */
13701               TREE_CHAIN (parm) = NULL_TREE;
13702               nonparms = chainon (nonparms, parm);
13703             }
13704         }
13705
13706       /* Get the decls in their original chain order and record in the
13707          function.  This is all and only the PARM_DECLs that were
13708          pushed into scope by the loop above.  */
13709       DECL_ARGUMENTS (fndecl) = getdecls ();
13710       storetags (chainon (parmtags, gettags ()));
13711     }
13712   else
13713     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13714
13715   /* Now store the final chain of decls for the arguments
13716      as the decl-chain of the current lexical scope.
13717      Put the enumerators in as well, at the front so that
13718      DECL_ARGUMENTS is not modified.  */
13719   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13720
13721   /* Now that we have initialized the parms, we can start their
13722      cleanups.  We cannot do this before, since expand_decl_cleanup
13723      should not be called before the parm can be used.  */
13724   while (cleanups)
13725     {
13726       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13727                            TREE_VALUE (cleanups));
13728       cleanups = TREE_CHAIN (cleanups);
13729     }
13730
13731   /* Create a binding contour which can be used to catch
13732      cleanup-generated temporaries.  */
13733   if (parms_have_cleanups)
13734     pushlevel (0);
13735
13736   /* Do the starting of the exception specifications, if we have any.  */
13737   if (flag_exceptions && !processing_template_decl
13738       && flag_enforce_eh_specs
13739       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13740     current_eh_spec_try_block = expand_start_eh_spec ();
13741 }
13742
13743 \f
13744 /* We have finished doing semantic analysis on DECL, but have not yet
13745    generated RTL for its body.  Save away our current state, so that
13746    when we want to generate RTL later we know what to do.  */
13747
13748 static void
13749 save_function_data (decl)
13750      tree decl;
13751 {
13752   struct cp_language_function *f;
13753
13754   /* Save the language-specific per-function data so that we can
13755      get it back when we really expand this function.  */
13756   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13757                       19990908);
13758
13759   /* Make a copy.  */
13760   f = ((struct cp_language_function *)
13761        xmalloc (sizeof (struct cp_language_function)));
13762   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13763   DECL_SAVED_FUNCTION_DATA (decl) = f;
13764
13765   /* Clear out the bits we don't need.  */
13766   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13767   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13768   f->x_named_label_uses = NULL;
13769   f->bindings = NULL;
13770
13771   /* When we get back here again, we will be expanding.  */
13772   f->x_expanding_p = 1;
13773
13774   /* If we've already decided that we cannot inline this function, we
13775      must remember that fact when we actually go to expand the
13776      function.  */
13777   f->cannot_inline = current_function_cannot_inline;
13778 }
13779
13780 /* At the end of every constructor we generate to code to return
13781    `this'.  Do that now.  */
13782
13783 static void
13784 finish_constructor_body ()
13785 {
13786   /* Any return from a constructor will end up here.  */
13787   if (ctor_label)
13788     add_stmt (build_stmt (LABEL_STMT, ctor_label));
13789
13790   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13791      generate the return, rather than a goto to CTOR_LABEL.  */
13792   ctor_label = NULL_TREE;
13793   /* In check_return_expr we translate an empty return from a
13794      constructor to a return of `this'.  */
13795   finish_return_stmt (NULL_TREE);
13796   /* Mark the end of the constructor.  */
13797   add_stmt (build_stmt (CTOR_STMT));
13798 }
13799
13800 /* At the end of every destructor we generate code to restore virtual
13801    function tables to the values desired by base classes and to call
13802    to base class destructors.  Do that now.  */
13803
13804 static void
13805 finish_destructor_body ()
13806 {
13807   tree compound_stmt;
13808   tree virtual_size;
13809   tree exprstmt;
13810   tree if_stmt;
13811
13812   /* Create a block to contain all the extra code.  */
13813   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13814
13815   /* Any return from a destructor will end up here.  */
13816   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13817
13818   /* Generate the code to call destructor on base class.  If this
13819      destructor belongs to a class with virtual functions, then set
13820      the virtual function table pointer to represent the type of our
13821      base class.  */
13822
13823   /* This side-effect makes call to `build_delete' generate the code
13824      we have to have at the end of this destructor.  `build_delete'
13825      will set the flag again.  */
13826   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13827
13828   exprstmt = build_delete (current_class_type,
13829                            current_class_ref,
13830                            sfk_base_destructor,
13831                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13832                            0);
13833
13834   if (exprstmt != error_mark_node
13835       && (TREE_CODE (exprstmt) != NOP_EXPR
13836           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13837           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13838     {
13839       if (exprstmt != void_zero_node)
13840         /* Don't call `expand_expr_stmt' if we're not going to do
13841            anything, since -Wall will give a diagnostic.  */
13842         finish_expr_stmt (exprstmt);
13843
13844       /* Run destructors for all virtual baseclasses.  */
13845       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13846         {
13847           tree vbases;
13848           tree if_stmt;
13849
13850           if_stmt = begin_if_stmt ();
13851           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13852                                       current_in_charge_parm,
13853                                       integer_two_node),
13854                                if_stmt);
13855
13856           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13857           /* The CLASSTYPE_VBASECLASSES list is in initialization
13858              order, so we have to march through it in reverse order.  */
13859           for (vbases = nreverse (copy_list (vbases));
13860                vbases;
13861                vbases = TREE_CHAIN (vbases))
13862             {
13863               tree vbase = TREE_VALUE (vbases);
13864               tree base_type = BINFO_TYPE (vbase);
13865
13866               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
13867                 {
13868                   tree base_ptr_type = build_pointer_type (base_type);
13869                   tree expr = current_class_ptr;
13870
13871                   /* Convert to the basetype here, as we know the layout is
13872                      fixed. What is more, if we let build_method_call do it,
13873                      it will use the vtable, which may have been clobbered
13874                      by the deletion of our primary base.  */
13875
13876                   expr = build1 (NOP_EXPR, base_ptr_type, expr);
13877                   expr = build (PLUS_EXPR, base_ptr_type, expr,
13878                                 BINFO_OFFSET (vbase));
13879                   expr = build_indirect_ref (expr, NULL);
13880                   expr = build_method_call (expr, base_dtor_identifier,
13881                                             NULL_TREE, vbase,
13882                                             LOOKUP_NORMAL);
13883                   finish_expr_stmt (expr);
13884                 }
13885             }
13886
13887           finish_then_clause (if_stmt);
13888           finish_if_stmt ();
13889         }
13890     }
13891
13892   virtual_size = c_sizeof (current_class_type);
13893
13894   /* At the end, call delete if that's what's requested.  */
13895
13896   /* FDIS sez: At the point of definition of a virtual destructor
13897      (including an implicit definition), non-placement operator delete
13898      shall be looked up in the scope of the destructor's class and if
13899      found shall be accessible and unambiguous.
13900
13901      This is somewhat unclear, but I take it to mean that if the class
13902      only defines placement deletes we don't do anything here.  So we
13903      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13904      they ever try to delete one of these.  */
13905   exprstmt = build_op_delete_call
13906     (DELETE_EXPR, current_class_ptr, virtual_size,
13907      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13908
13909   if_stmt = begin_if_stmt ();
13910   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13911                               current_in_charge_parm,
13912                               integer_one_node),
13913                        if_stmt);
13914   finish_expr_stmt (exprstmt);
13915   finish_then_clause (if_stmt);
13916   finish_if_stmt ();
13917
13918   /* Close the block we started above.  */
13919   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13920 }
13921
13922 /* Finish up a function declaration and compile that function
13923    all the way to assembler language output.  The free the storage
13924    for the function definition.
13925
13926    FLAGS is a bitwise or of the following values:
13927      1 - CALL_POPLEVEL
13928        An extra call to poplevel (and expand_end_bindings) must be
13929        made to take care of the binding contour for the base
13930        initializers.  This is only relevant for constructors.
13931      2 - INCLASS_INLINE
13932        We just finished processing the body of an in-class inline
13933        function definition.  (This processing will have taken place
13934        after the class definition is complete.)  */
13935
13936 tree
13937 finish_function (flags)
13938      int flags;
13939 {
13940   register tree fndecl = current_function_decl;
13941   tree fntype, ctype = NULL_TREE;
13942   int call_poplevel = (flags & 1) != 0;
13943   int inclass_inline = (flags & 2) != 0;
13944   int nested;
13945
13946   /* When we get some parse errors, we can end up without a
13947      current_function_decl, so cope.  */
13948   if (fndecl == NULL_TREE)
13949     return error_mark_node;
13950
13951   nested = function_depth > 1;
13952   fntype = TREE_TYPE (fndecl);
13953
13954   /*  TREE_READONLY (fndecl) = 1;
13955       This caused &foo to be of type ptr-to-const-function
13956       which then got a warning when stored in a ptr-to-function variable.  */
13957
13958   my_friendly_assert (building_stmt_tree (), 20000911);
13959
13960   /* For a cloned function, we've already got all the code we need;
13961      there's no need to add any extra bits.  */
13962   if (!DECL_CLONED_FUNCTION_P (fndecl))
13963     {
13964       if (DECL_CONSTRUCTOR_P (fndecl))
13965         {
13966           finish_constructor_body ();
13967           if (call_poplevel)
13968             do_poplevel ();
13969         }
13970       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13971         finish_destructor_body ();
13972       else if (DECL_MAIN_P (fndecl))
13973         {
13974           /* Make it so that `main' always returns 0 by default.  */
13975 #ifdef VMS
13976           finish_return_stmt (integer_one_node);
13977 #else
13978           finish_return_stmt (integer_zero_node);
13979 #endif
13980         }
13981
13982       /* Finish dealing with exception specifiers.  */
13983       if (flag_exceptions && !processing_template_decl
13984           && flag_enforce_eh_specs
13985           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13986         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13987                             (TREE_TYPE (current_function_decl)),
13988                             current_eh_spec_try_block);
13989     }
13990
13991   /* If we're saving up tree structure, tie off the function now.  */
13992   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13993
13994   /* This must come after expand_function_end because cleanups might
13995      have declarations (from inline functions) that need to go into
13996      this function's blocks.  */
13997   if (current_binding_level->parm_flag != 1)
13998     my_friendly_abort (122);
13999   poplevel (1, 0, 1);
14000
14001   /* Remember that we were in class scope.  */
14002   if (current_class_name)
14003     ctype = current_class_type;
14004
14005   /* Must mark the RESULT_DECL as being in this function.  */
14006   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14007
14008   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14009      to the FUNCTION_DECL node itself.  */
14010   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14011
14012   /* Save away current state, if appropriate.  */
14013   if (!processing_template_decl)
14014     save_function_data (fndecl);
14015
14016   /* If this function calls `setjmp' it cannot be inlined.  When
14017      `longjmp' is called it is not guaranteed to restore the value of
14018      local variables that have been modified since the call to
14019      `setjmp'.  So, if were to inline this function into some caller
14020      `c', then when we `longjmp', we might not restore all variables
14021      in `c'.  (It might seem, at first blush, that there's no way for
14022      this function to modify local variables in `c', but their
14023      addresses may have been stored somewhere accessible to this
14024      function.)  */
14025   if (!processing_template_decl && calls_setjmp_p (fndecl))
14026     DECL_UNINLINABLE (fndecl) = 1;
14027
14028   /* Clear out memory we no longer need.  */
14029   free_after_parsing (cfun);
14030   /* Since we never call rest_of_compilation, we never clear
14031      CFUN.  Do so explicitly.  */
14032   free_after_compilation (cfun);
14033   cfun = NULL;
14034
14035   /* If this is a in-class inline definition, we may have to pop the
14036      bindings for the template parameters that we added in
14037      maybe_begin_member_template_processing when start_function was
14038      called.  */
14039   if (inclass_inline)
14040     maybe_end_member_template_processing ();
14041
14042   /* Leave the scope of the class.  */
14043   if (ctype)
14044     pop_nested_class ();
14045
14046   --function_depth;
14047
14048   /* Clean up.  */
14049   if (! nested)
14050     /* Let the error reporting routines know that we're outside a
14051        function.  For a nested function, this value is used in
14052        pop_cp_function_context and then reset via pop_function_context.  */
14053     current_function_decl = NULL_TREE;
14054
14055   return fndecl;
14056 }
14057 \f
14058 /* Create the FUNCTION_DECL for a function definition.
14059    DECLSPECS and DECLARATOR are the parts of the declaration;
14060    they describe the return type and the name of the function,
14061    but twisted together in a fashion that parallels the syntax of C.
14062
14063    This function creates a binding context for the function body
14064    as well as setting up the FUNCTION_DECL in current_function_decl.
14065
14066    Returns a FUNCTION_DECL on success.
14067
14068    If the DECLARATOR is not suitable for a function (it defines a datum
14069    instead), we return 0, which tells yyparse to report a parse error.
14070
14071    May return void_type_node indicating that this method is actually
14072    a friend.  See grokfield for more details.
14073
14074    Came here with a `.pushlevel' .
14075
14076    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14077    CHANGES TO CODE IN `grokfield'.  */
14078
14079 tree
14080 start_method (declspecs, declarator, attrlist)
14081      tree declarator, declspecs, attrlist;
14082 {
14083   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14084                                 attrlist);
14085
14086   /* Something too ugly to handle.  */
14087   if (fndecl == NULL_TREE)
14088     return NULL_TREE;
14089
14090   /* Pass friends other than inline friend functions back.  */
14091   if (fndecl == void_type_node)
14092     return fndecl;
14093
14094   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14095     /* Not a function, tell parser to report parse error.  */
14096     return NULL_TREE;
14097
14098   if (DECL_IN_AGGR_P (fndecl))
14099     {
14100       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14101         {
14102           if (DECL_CONTEXT (fndecl)
14103               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14104             cp_error ("`%D' is already defined in class `%T'", fndecl,
14105                       DECL_CONTEXT (fndecl));
14106         }
14107       return void_type_node;
14108     }
14109
14110   check_template_shadow (fndecl);
14111
14112   DECL_THIS_INLINE (fndecl) = 1;
14113
14114   if (flag_default_inline)
14115     DECL_INLINE (fndecl) = 1;
14116
14117   /* We process method specializations in finish_struct_1.  */
14118   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14119     fndecl = push_template_decl (fndecl);
14120
14121   if (! DECL_FRIEND_P (fndecl))
14122     {
14123       if (TREE_CHAIN (fndecl))
14124         {
14125           fndecl = copy_node (fndecl);
14126           TREE_CHAIN (fndecl) = NULL_TREE;
14127         }
14128
14129       if (DECL_CONSTRUCTOR_P (fndecl))
14130         {
14131           if (! grok_ctor_properties (current_class_type, fndecl))
14132             return void_type_node;
14133         }
14134       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14135         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14136     }
14137
14138   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14139
14140   /* Make a place for the parms */
14141   pushlevel (0);
14142   current_binding_level->parm_flag = 1;
14143
14144   DECL_IN_AGGR_P (fndecl) = 1;
14145   return fndecl;
14146 }
14147
14148 /* Go through the motions of finishing a function definition.
14149    We don't compile this method until after the whole class has
14150    been processed.
14151
14152    FINISH_METHOD must return something that looks as though it
14153    came from GROKFIELD (since we are defining a method, after all).
14154
14155    This is called after parsing the body of the function definition.
14156    STMTS is the chain of statements that makes up the function body.
14157
14158    DECL is the ..._DECL that `start_method' provided.  */
14159
14160 tree
14161 finish_method (decl)
14162      tree decl;
14163 {
14164   register tree fndecl = decl;
14165   tree old_initial;
14166
14167   register tree link;
14168
14169   if (decl == void_type_node)
14170     return decl;
14171
14172   old_initial = DECL_INITIAL (fndecl);
14173
14174   /* Undo the level for the parms (from start_method).
14175      This is like poplevel, but it causes nothing to be
14176      saved.  Saving information here confuses symbol-table
14177      output routines.  Besides, this information will
14178      be correctly output when this method is actually
14179      compiled.  */
14180
14181   /* Clear out the meanings of the local variables of this level;
14182      also record in each decl which block it belongs to.  */
14183
14184   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14185     {
14186       if (DECL_NAME (link) != NULL_TREE)
14187         pop_binding (DECL_NAME (link), link);
14188       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14189       DECL_CONTEXT (link) = NULL_TREE;
14190     }
14191
14192   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14193                       (HOST_WIDE_INT) current_binding_level->level_chain,
14194                       current_binding_level->parm_flag,
14195                       current_binding_level->keep);
14196
14197   poplevel (0, 0, 0);
14198
14199   DECL_INITIAL (fndecl) = old_initial;
14200
14201   /* We used to check if the context of FNDECL was different from
14202      current_class_type as another way to get inside here.  This didn't work
14203      for String.cc in libg++.  */
14204   if (DECL_FRIEND_P (fndecl))
14205     {
14206       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14207         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14208       decl = void_type_node;
14209     }
14210
14211   return decl;
14212 }
14213 \f
14214 /* Called when a new struct TYPE is defined.
14215    If this structure or union completes the type of any previous
14216    variable declaration, lay it out and output its rtl.  */
14217
14218 void
14219 hack_incomplete_structures (type)
14220      tree type;
14221 {
14222   tree *list;
14223   struct binding_level *level;
14224
14225   if (!type) /* Don't do this for class templates.  */
14226     return;
14227
14228   if (namespace_bindings_p ())
14229     {
14230       level = 0;
14231       list = &namespace_scope_incomplete;
14232     }
14233   else
14234     {
14235       level = innermost_nonclass_level ();
14236       list = &level->incomplete;
14237     }
14238
14239   while (1)
14240     {
14241       while (*list)
14242         {
14243           tree decl = TREE_VALUE (*list);
14244           if ((decl && TREE_TYPE (decl) == type)
14245               || (TREE_TYPE (decl)
14246                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14247                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14248             {
14249               int toplevel = toplevel_bindings_p ();
14250               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14251                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14252                 layout_type (TREE_TYPE (decl));
14253               layout_decl (decl, 0);
14254               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14255               if (! toplevel)
14256                 {
14257                   tree cleanup;
14258                   expand_decl (decl);
14259                   cleanup = maybe_build_cleanup (decl);
14260                   expand_decl_init (decl);
14261                   if (! expand_decl_cleanup (decl, cleanup))
14262                     cp_error ("parser lost in parsing declaration of `%D'",
14263                               decl);
14264                 }
14265               *list = TREE_CHAIN (*list);
14266             }
14267           else
14268             list = &TREE_CHAIN (*list);
14269         }
14270
14271       /* Keep looking through artificial binding levels generated
14272          for local variables.  */
14273       if (level && level->keep == 2)
14274         {
14275           level = level->level_chain;
14276           list = &level->incomplete;
14277         }
14278       else
14279         break;
14280     }
14281 }
14282
14283 /* If DECL is of a type which needs a cleanup, build that cleanup
14284    here.  */
14285
14286 tree
14287 maybe_build_cleanup (decl)
14288      tree decl;
14289 {
14290   tree type = TREE_TYPE (decl);
14291
14292   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14293     {
14294       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14295       tree rval;
14296
14297       if (TREE_CODE (type) == ARRAY_TYPE)
14298         rval = decl;
14299       else
14300         {
14301           mark_addressable (decl);
14302           rval = build_unary_op (ADDR_EXPR, decl, 0);
14303         }
14304
14305       /* Optimize for space over speed here.  */
14306       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14307           || flag_expensive_optimizations)
14308         flags |= LOOKUP_NONVIRTUAL;
14309
14310       rval = build_delete (TREE_TYPE (rval), rval,
14311                            sfk_complete_destructor, flags, 0);
14312
14313       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14314           && ! TYPE_HAS_DESTRUCTOR (type))
14315         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14316                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14317
14318       return rval;
14319     }
14320   return 0;
14321 }
14322 \f
14323 /* When a stmt has been parsed, this function is called.  */
14324
14325 void
14326 finish_stmt ()
14327 {
14328   /* Always assume this statement was not an expression statement.  If
14329      it actually was an expression statement, its our callers
14330      responsibility to fix this up.  */
14331   last_expr_type = NULL_TREE;
14332 }
14333
14334 /* DECL was originally constructed as a non-static member function,
14335    but turned out to be static.  Update it accordingly.  */
14336
14337 void
14338 revert_static_member_fn (decl)
14339      tree decl;
14340 {
14341   tree tmp;
14342   tree function = TREE_TYPE (decl);
14343   tree args = TYPE_ARG_TYPES (function);
14344
14345   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14346       != TYPE_UNQUALIFIED)
14347     cp_error ("static member function `%#D' declared with type qualifiers",
14348               decl);
14349
14350   args = TREE_CHAIN (args);
14351   tmp = build_function_type (TREE_TYPE (function), args);
14352   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14353   tmp = build_exception_variant (tmp,
14354                                  TYPE_RAISES_EXCEPTIONS (function));
14355   TREE_TYPE (decl) = tmp;
14356   if (DECL_ARGUMENTS (decl))
14357     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14358   DECL_STATIC_FUNCTION_P (decl) = 1;
14359 }
14360
14361 /* Initialize the variables used during compilation of a C++
14362    function.  */
14363
14364 static void
14365 push_cp_function_context (f)
14366      struct function *f;
14367 {
14368   struct cp_language_function *p
14369     = ((struct cp_language_function *)
14370        xcalloc (1, sizeof (struct cp_language_function)));
14371   f->language = (struct language_function *) p;
14372
14373   /* It takes an explicit call to expand_body to generate RTL for a
14374      function.  */
14375   expanding_p = 0;
14376
14377   /* Whenever we start a new function, we destroy temporaries in the
14378      usual way.  */
14379   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14380 }
14381
14382 /* Free the language-specific parts of F, now that we've finished
14383    compiling the function.  */
14384
14385 static void
14386 pop_cp_function_context (f)
14387      struct function *f;
14388 {
14389   if (f->language)
14390     free (f->language);
14391   f->language = 0;
14392 }
14393
14394 /* Mark P for GC.  */
14395
14396 static void
14397 mark_lang_function (p)
14398      struct cp_language_function *p;
14399 {
14400   if (!p)
14401     return;
14402
14403   mark_c_language_function (&p->base);
14404
14405   ggc_mark_tree (p->x_ctor_label);
14406   ggc_mark_tree (p->x_dtor_label);
14407   ggc_mark_tree (p->x_current_class_ptr);
14408   ggc_mark_tree (p->x_current_class_ref);
14409   ggc_mark_tree (p->x_eh_spec_try_block);
14410
14411   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14412   mark_binding_level (&p->bindings);
14413 }
14414
14415 /* Mark the language-specific data in F for GC.  */
14416
14417 static void
14418 mark_cp_function_context (f)
14419      struct function *f;
14420 {
14421   mark_lang_function ((struct cp_language_function *) f->language);
14422 }
14423
14424 void
14425 lang_mark_tree (t)
14426      tree t;
14427 {
14428   enum tree_code code = TREE_CODE (t);
14429   if (code == IDENTIFIER_NODE)
14430     {
14431       struct lang_identifier *li = (struct lang_identifier *) t;
14432       struct lang_id2 *li2 = li->x;
14433       ggc_mark_tree (li->namespace_bindings);
14434       ggc_mark_tree (li->bindings);
14435       ggc_mark_tree (li->class_value);
14436       ggc_mark_tree (li->class_template_info);
14437
14438       if (li2)
14439         {
14440           ggc_mark_tree (li2->label_value);
14441           ggc_mark_tree (li2->implicit_decl);
14442           ggc_mark_tree (li2->error_locus);
14443         }
14444     }
14445   else if (code == CPLUS_BINDING)
14446     {
14447       if (BINDING_HAS_LEVEL_P (t))
14448         mark_binding_level (&BINDING_LEVEL (t));
14449       else
14450         ggc_mark_tree (BINDING_SCOPE (t));
14451       ggc_mark_tree (BINDING_VALUE (t));
14452     }
14453   else if (code == OVERLOAD)
14454     ggc_mark_tree (OVL_FUNCTION (t));
14455   else if (code == TEMPLATE_PARM_INDEX)
14456     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14457   else if (TREE_CODE_CLASS (code) == 'd')
14458     {
14459       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14460
14461       if (ld)
14462         {
14463           ggc_mark (ld);
14464           c_mark_lang_decl (&ld->decl_flags.base);
14465           if (!DECL_GLOBAL_CTOR_P (t)
14466               && !DECL_GLOBAL_DTOR_P (t)
14467               && !DECL_THUNK_P (t))
14468             ggc_mark_tree (ld->decl_flags.u2.access);
14469           else if (DECL_THUNK_P (t))
14470             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14471           if (TREE_CODE (t) != NAMESPACE_DECL)
14472             ggc_mark_tree (ld->decl_flags.u.template_info);
14473           else
14474             mark_binding_level (&NAMESPACE_LEVEL (t));
14475           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14476             {
14477               ggc_mark_tree (ld->befriending_classes);
14478               ggc_mark_tree (ld->context);
14479               ggc_mark_tree (ld->cloned_function);
14480               if (!DECL_OVERLOADED_OPERATOR_P (t))
14481                 ggc_mark_tree (ld->u2.vtt_parm);
14482               if (TREE_CODE (t) == TYPE_DECL)
14483                 ggc_mark_tree (ld->u.sorted_fields);
14484               else if (TREE_CODE (t) == FUNCTION_DECL
14485                        && !DECL_PENDING_INLINE_P (t))
14486                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14487             }
14488         }
14489     }
14490   else if (TREE_CODE_CLASS (code) == 't')
14491     {
14492       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14493
14494       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14495                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14496         {
14497           ggc_mark (lt);
14498           ggc_mark_tree (lt->primary_base);
14499           ggc_mark_tree (lt->vfields);
14500           ggc_mark_tree (lt->vbases);
14501           ggc_mark_tree (lt->tags);
14502           ggc_mark_tree (lt->size);
14503           ggc_mark_tree (lt->pure_virtuals);
14504           ggc_mark_tree (lt->friend_classes);
14505           ggc_mark_tree (lt->rtti);
14506           ggc_mark_tree (lt->methods);
14507           ggc_mark_tree (lt->template_info);
14508           ggc_mark_tree (lt->befriending_classes);
14509         }
14510       else if (lt)
14511         /* In the case of pointer-to-member function types, the
14512            TYPE_LANG_SPECIFIC is really just a tree.  */
14513         ggc_mark_tree ((tree) lt);
14514     }
14515 }
14516
14517 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14518    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14519
14520 tree
14521 identifier_global_value (t)
14522      tree t;
14523 {
14524   return IDENTIFIER_GLOBAL_VALUE (t);
14525 }
14526
14527 /* Build the void_list_node (void_type_node having been created).  */
14528 tree
14529 build_void_list_node ()
14530 {
14531   tree t = build_tree_list (NULL_TREE, void_type_node);
14532   TREE_PARMLIST (t) = 1;
14533   return t;
14534 }
14535
14536 static int
14537 cp_missing_noreturn_ok_p (decl)
14538      tree decl;
14539 {
14540   /* A missing noreturn is ok for the `main' function.  */
14541   return MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
14542 }