gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "flags.h"
  37 #include "cp-tree.h"
  38 #include "decl.h"
  39 #include "lex.h"
  40 #include <signal.h>
  41 #include "defaults.h"
  42 #include "output.h"
  43 #include "except.h"
  44 #include "toplev.h"
  45 #include "../hash.h"
  46 #include "defaults.h"
  47 #include "ggc.h"
  48
  49 extern int current_class_depth;
  50
  51 extern tree static_ctors, static_dtors;
  52
  53 extern tree global_namespace;
  54
  55 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  56
  57 /* Use garbage collection.  */
  58
  59 int ggc_p = 1;
  60
  61 #ifndef WCHAR_UNSIGNED
  62 #define WCHAR_UNSIGNED 0
  63 #endif
  64
  65 #ifndef CHAR_TYPE_SIZE
  66 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  67 #endif
  68
  69 #ifndef BOOL_TYPE_SIZE
  70 #ifdef SLOW_BYTE_ACCESS
  71 /* In the new ABI, `bool' has size and alignment `1', on all
  72    platforms.  */
  73 #define BOOL_TYPE_SIZE \
  74   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  75 #else
  76 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  77 #endif
  78 #endif
  79
  80 /* We let tm.h override the types used here, to handle trivial differences
  81    such as the choice of unsigned int or long unsigned int for size_t.
  82    When machines start needing nontrivial differences in the size type,
  83    it would be best to do something here to figure out automatically
  84    from other information what type to use.  */
  85
  86 #ifndef SIZE_TYPE
  87 #define SIZE_TYPE "long unsigned int"
  88 #endif
  89
  90 #ifndef PTRDIFF_TYPE
  91 #define PTRDIFF_TYPE "long int"
  92 #endif
  93
  94 #ifndef WCHAR_TYPE
  95 #define WCHAR_TYPE "int"
  96 #endif
  97
  98 static tree grokparms                           PARAMS ((tree, int));
  99 static const char *redeclaration_error_message  PARAMS ((tree, tree));
 100
 101 static void push_binding_level PARAMS ((struct binding_level *, int,
 102                                       int));
 103 static void pop_binding_level PARAMS ((void));
 104 static void suspend_binding_level PARAMS ((void));
 105 static void resume_binding_level PARAMS ((struct binding_level *));
 106 static struct binding_level *make_binding_level PARAMS ((void));
 107 static void declare_namespace_level PARAMS ((void));
 108 static void signal_catch PARAMS ((int)) ATTRIBUTE_NORETURN;
 109 static int decl_jump_unsafe PARAMS ((tree));
 110 static void storedecls PARAMS ((tree));
 111 static void require_complete_types_for_parms PARAMS ((tree));
 112 static int ambi_op_p PARAMS ((enum tree_code));
 113 static int unary_op_p PARAMS ((enum tree_code));
 114 static tree store_bindings PARAMS ((tree, tree));
 115 static tree lookup_tag_reverse PARAMS ((tree, tree));
 116 static tree obscure_complex_init PARAMS ((tree, tree));
 117 static tree lookup_name_real PARAMS ((tree, int, int, int));
 118 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 119 static void grok_reference_init PARAMS ((tree, tree, tree));
 120 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 121                               enum overload_flags, tree,
 122                               tree, int, int, int, int, int, int, tree));
 123 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 124 static tree lookup_tag PARAMS ((enum tree_code, tree,
 125                               struct binding_level *, int));
 126 static void set_identifier_type_value_with_scope
 127         PARAMS ((tree, tree, struct binding_level *));
 128 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 129 static void record_unknown_type PARAMS ((tree, const char *));
 130 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
 131 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 132 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 133                                   int));
 134 static void lang_print_error_function PARAMS ((const char *));
 135 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 136 static void check_for_uninitialized_const_var PARAMS ((tree));
 137 static unsigned long typename_hash PARAMS ((hash_table_key));
 138 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 139 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 140 static int add_binding PARAMS ((tree, tree));
 141 static void pop_binding PARAMS ((tree, tree));
 142 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 143 static tree find_binding PARAMS ((tree, tree));
 144 static tree select_decl PARAMS ((tree, int));
 145 static int lookup_flags PARAMS ((int, int));
 146 static tree qualify_lookup PARAMS ((tree, int));
 147 static tree record_builtin_java_type PARAMS ((const char *, int));
 148 static const char *tag_name PARAMS ((enum tag_types code));
 149 static void find_class_binding_level PARAMS ((void));
 150 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 151 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 152 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 153 static int walk_globals_r PARAMS ((tree, void *));
 154 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 155 static tree make_label_decl PARAMS ((tree, int));
 156 static void use_label PARAMS ((tree));
 157 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 158                                            const char *, int));
 159 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 160 static void check_switch_goto PARAMS ((struct binding_level *));
 161 static void check_previous_gotos PARAMS ((tree));
 162 static void pop_label PARAMS ((tree, tree));
 163 static void pop_labels PARAMS ((tree));
 164 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 165 static void layout_var_decl PARAMS ((tree));
 166 static void maybe_commonize_var PARAMS ((tree));
 167 static tree check_initializer PARAMS ((tree, tree));
 168 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 169 static void push_cp_function_context PARAMS ((struct function *));
 170 static void pop_cp_function_context PARAMS ((struct function *));
 171 static void mark_binding_level PARAMS ((void *));
 172 static void mark_named_label_lists PARAMS ((void *, void *));
 173 static void mark_cp_function_context PARAMS ((struct function *));
 174 static void mark_saved_scope PARAMS ((void *));
 175 static void mark_lang_function PARAMS ((struct language_function *));
 176 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 177 static void save_function_data PARAMS ((tree));
 178 static void check_function_type PARAMS ((tree));
 179 static void destroy_local_var PARAMS ((tree));
 180 static void finish_constructor_body PARAMS ((void));
 181 static void finish_destructor_body PARAMS ((void));
 182 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 183 static tree get_atexit_node PARAMS ((void));
 184 static tree get_dso_handle_node PARAMS ((void));
 185 static tree start_cleanup_fn PARAMS ((void));
 186 static void end_cleanup_fn PARAMS ((void));
 187 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 188 static void initialize_predefined_identifiers PARAMS ((void));
 189 static tree check_special_function_return_type
 190   PARAMS ((special_function_kind, tree, tree, tree));
 191 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 192 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 193
 194 #if defined (DEBUG_CP_BINDING_LEVELS)
 195 static void indent PARAMS ((void));
 196 #endif
 197
 198 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 199 tree error_mark_list;
 200
 201 /* The following symbols are subsumed in the cp_global_trees array, and
 202    listed here individually for documentation purposes.
 203
 204    C++ extensions
 205         tree wchar_decl_node;
 206         tree void_zero_node;
 207
 208         tree vtable_entry_type;
 209         tree delta_type_node;
 210 #if 0
 211    Old rtti stuff.
 212         tree __baselist_desc_type_node;
 213         tree __i_desc_type_node, __m_desc_type_node;
 214         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 215 #endif
 216         tree __t_desc_type_node;
 217 #if 0
 218         tree __tp_desc_type_node;
 219 #endif
 220         tree ti_desc_type_node;
 221         tree bltn_desc_type_node, ptr_desc_type_node;
 222         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 223         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 224         tree ptm_desc_type_node;
 225         tree base_desc_type_node;
 226 #if 0
 227    Not needed yet?  May be needed one day?
 228         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 229         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 230         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 231 #endif
 232
 233         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 234         tree unknown_type_node;
 235
 236    Array type `vtable_entry_type[]'
 237
 238         tree vtbl_type_node;
 239         tree vtbl_ptr_type_node;
 240
 241    Namespaces,
 242
 243         tree std_node;
 244         tree abi_node;
 245
 246    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 247    one that the user will declare, but sufficient to be called
 248    by routines that want to abort the program.
 249
 250         tree abort_fndecl;
 251
 252    The FUNCTION_DECL for the default `::operator delete'.
 253
 254         tree global_delete_fndecl;
 255
 256    Used by RTTI
 257         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 258         tree tinfo_var_id;
 259
 260 */
 261
 262 tree cp_global_trees[CPTI_MAX];
 263
 264 /* Indicates that there is a type value in some namespace, although
 265    that is not necessarily in scope at the moment.  */
 266
 267 static tree global_type_node;
 268
 269 /* Namespace std.  */
 270 int in_std;
 271
 272 /* Expect only namespace names now. */
 273 static int only_namespace_names;
 274
 275 /* If original DECL_RESULT of current function was a register,
 276    but due to being an addressable named return value, would up
 277    on the stack, this variable holds the named return value's
 278    original location.  */
 279
 280 #define original_result_rtx cp_function_chain->x_result_rtx
 281
 282 /* Used only for jumps to as-yet undefined labels, since jumps to
 283    defined labels can have their validity checked immediately.  */
 284
 285 struct named_label_use_list
 286 {
 287   struct binding_level *binding_level;
 288   tree names_in_scope;
 289   tree label_decl;
 290   const char *filename_o_goto;
 291   int lineno_o_goto;
 292   struct named_label_use_list *next;
 293 };
 294
 295 #define named_label_uses cp_function_chain->x_named_label_uses
 296
 297 /* A list of objects which have constructors or destructors
 298    which reside in the global scope.  The decl is stored in
 299    the TREE_VALUE slot and the initializer is stored
 300    in the TREE_PURPOSE slot.  */
 301 tree static_aggregates;
 302
 303 /* -- end of C++ */
 304
 305 /* A node for the integer constants 2, and 3.  */
 306
 307 tree integer_two_node, integer_three_node;
 308
 309 /* Parsing a function declarator leaves here a chain of structure
 310    and enum types declared in the parmlist.  */
 311
 312 static tree last_function_parm_tags;
 313
 314 /* Similar, for last_function_parm_tags.  */
 315 tree last_function_parms;
 316 static tree current_function_parm_tags;
 317
 318 /* A list of all LABEL_DECLs in the function that have names.  Here so
 319    we can clear out their names' definitions at the end of the
 320    function, and so we can check the validity of jumps to these labels.  */
 321
 322 struct named_label_list
 323 {
 324   struct binding_level *binding_level;
 325   tree names_in_scope;
 326   tree old_value;
 327   tree label_decl;
 328   tree bad_decls;
 329   int eh_region;
 330   struct named_label_list *next;
 331 };
 332
 333 #define named_labels cp_function_chain->x_named_labels
 334
 335 /* Set to 0 at beginning of a function definition, and whenever
 336    a label (case or named) is defined.  Set to value of expression
 337    returned from function when that value can be transformed into
 338    a named return value.  */
 339
 340 tree current_function_return_value;
 341
 342 /* Nonzero means use the ISO C99 dialect of C.  */
 343
 344 int flag_isoc99;
 345
 346 /* Nonzero means give `double' the same size as `float'.  */
 347
 348 extern int flag_short_double;
 349
 350 /* Nonzero means don't recognize any builtin functions.  */
 351
 352 extern int flag_no_builtin;
 353
 354 /* Nonzero means don't recognize the non-ANSI builtin functions.
 355    -ansi sets this.  */
 356
 357 extern int flag_no_nonansi_builtin;
 358
 359 /* Nonzero if we want to conserve space in the .o files.  We do this
 360    by putting uninitialized data and runtime initialized data into
 361    .common instead of .data at the expense of not flagging multiple
 362    definitions.  */
 363 extern int flag_conserve_space;
 364 \f
 365 /* C and C++ flags are in decl2.c.  */
 366
 367 /* Flag used when debugging spew.c */
 368
 369 extern int spew_debug;
 370
 371 /* A expression of value 0 with the same precision as a sizetype
 372    node, but signed.  */
 373 tree signed_size_zero_node;
 374
 375 /* The name of the anonymous namespace, throughout this translation
 376    unit.  */
 377 tree anonymous_namespace_name;
 378
 379 \f
 380 /* For each binding contour we allocate a binding_level structure
 381    which records the names defined in that contour.
 382    Contours include:
 383     0) the global one
 384     1) one for each function definition,
 385        where internal declarations of the parameters appear.
 386     2) one for each compound statement,
 387        to record its declarations.
 388
 389    The current meaning of a name can be found by searching the levels
 390    from the current one out to the global one.
 391
 392    Off to the side, may be the class_binding_level.  This exists only
 393    to catch class-local declarations.  It is otherwise nonexistent.
 394
 395    Also there may be binding levels that catch cleanups that must be
 396    run when exceptions occur.  Thus, to see whether a name is bound in
 397    the current scope, it is not enough to look in the
 398    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 399    instead.  */
 400
 401 /* Note that the information in the `names' component of the global contour
 402    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 403
 404 struct binding_level
 405   {
 406     /* A chain of _DECL nodes for all variables, constants, functions,
 407        and typedef types.  These are in the reverse of the order
 408        supplied.  There may be OVERLOADs on this list, too, but they
 409        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 410     tree names;
 411
 412     /* A list of structure, union and enum definitions, for looking up
 413        tag names.
 414        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 415        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 416        or ENUMERAL_TYPE node.
 417
 418        C++: the TREE_VALUE nodes can be simple types for
 419        component_bindings.  */
 420     tree tags;
 421
 422     /* A list of USING_DECL nodes. */
 423     tree usings;
 424
 425     /* A list of used namespaces. PURPOSE is the namespace,
 426        VALUE the common ancestor with this binding_level's namespace. */
 427     tree using_directives;
 428
 429     /* If this binding level is the binding level for a class, then
 430        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 431        is the name of an entity bound in the class; the TREE_VALUE is
 432        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 433        when leaving class scope, we can restore the
 434        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 435        the DECL bound by this name in the class.  */
 436     tree class_shadowed;
 437
 438     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 439        is used for all binding levels.  */
 440     tree type_shadowed;
 441
 442     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 443        label in this scope.  The TREE_PURPOSE is the previous value of
 444        the IDENTIFIER_LABEL VALUE.  */
 445     tree shadowed_labels;
 446
 447     /* For each level (except not the global one),
 448        a chain of BLOCK nodes for all the levels
 449        that were entered and exited one level down.  */
 450     tree blocks;
 451
 452     /* The BLOCK node for this level, if one has been preallocated.
 453        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 454     tree this_block;
 455
 456     /* The _TYPE node for this level, if parm_flag == 2.  */
 457     tree this_class;
 458
 459     /* The binding level which this one is contained in (inherits from).  */
 460     struct binding_level *level_chain;
 461
 462     /* List of decls in `names' that have incomplete
 463        structure or union types.  */
 464     tree incomplete;
 465
 466     /* List of VAR_DECLS saved from a previous for statement.
 467        These would be dead in ISO-conforming code, but might
 468        be referenced in ARM-era code.  These are stored in a
 469        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 470     tree dead_vars_from_for;
 471
 472     /* 1 for the level that holds the parameters of a function.
 473        2 for the level that holds a class declaration.  */
 474     unsigned parm_flag : 2;
 475
 476     /* 1 means make a BLOCK for this level regardless of all else.
 477        2 for temporary binding contours created by the compiler.  */
 478     unsigned keep : 2;
 479
 480     /* Nonzero if this level "doesn't exist" for tags.  */
 481     unsigned tag_transparent : 1;
 482
 483     /* Nonzero if this level can safely have additional
 484        cleanup-needing variables added to it.  */
 485     unsigned more_cleanups_ok : 1;
 486     unsigned have_cleanups : 1;
 487
 488     /* Nonzero if this scope is for storing the decls for template
 489        parameters and generic decls; these decls will be discarded and
 490        replaced with a TEMPLATE_DECL.  */
 491     unsigned template_parms_p : 1;
 492
 493     /* Nonzero if this scope corresponds to the `<>' in a
 494        `template <>' clause.  Whenever this flag is set,
 495        TEMPLATE_PARMS_P will be set as well.  */
 496     unsigned template_spec_p : 1;
 497
 498     /* This is set for a namespace binding level.  */
 499     unsigned namespace_p : 1;
 500
 501     /* True if this level is that of a for-statement where we need to
 502        worry about ambiguous (ARM or ISO) scope rules.  */
 503     unsigned is_for_scope : 1;
 504
 505     /* True if this level corresponds to an EH region, as for a try block.
 506        Currently this information is only available while building the
 507        tree structure.  */
 508     unsigned eh_region : 1;
 509
 510     /* Four bits left for this word.  */
 511
 512 #if defined(DEBUG_CP_BINDING_LEVELS)
 513     /* Binding depth at which this level began.  */
 514     unsigned binding_depth;
 515 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 516   };
 517
 518 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 519
 520 /* The binding level currently in effect.  */
 521
 522 #define current_binding_level                   \
 523   (cfun                                         \
 524    ? cp_function_chain->bindings                \
 525    : scope_chain->bindings)
 526
 527 /* The binding level of the current class, if any.  */
 528
 529 #define class_binding_level scope_chain->class_bindings
 530
 531 /* A chain of binding_level structures awaiting reuse.  */
 532
 533 static struct binding_level *free_binding_level;
 534
 535 /* The outermost binding level, for names of file scope.
 536    This is created when the compiler is started and exists
 537    through the entire run.  */
 538
 539 static struct binding_level *global_binding_level;
 540
 541 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 542
 543 static int keep_next_level_flag;
 544
 545 #if defined(DEBUG_CP_BINDING_LEVELS)
 546 static int binding_depth = 0;
 547 static int is_class_level = 0;
 548
 549 static void
 550 indent ()
 551 {
 552   register unsigned i;
 553
 554   for (i = 0; i < binding_depth*2; i++)
 555     putc (' ', stderr);
 556 }
 557 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 558
 559 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 560
 561 static void
 562 push_binding_level (newlevel, tag_transparent, keep)
 563      struct binding_level *newlevel;
 564      int tag_transparent, keep;
 565 {
 566   /* Add this level to the front of the chain (stack) of levels that
 567      are active.  */
 568   bzero ((char*) newlevel, sizeof (struct binding_level));
 569   newlevel->level_chain = current_binding_level;
 570   current_binding_level = newlevel;
 571   newlevel->tag_transparent = tag_transparent;
 572   newlevel->more_cleanups_ok = 1;
 573
 574   newlevel->keep = keep;
 575 #if defined(DEBUG_CP_BINDING_LEVELS)
 576   newlevel->binding_depth = binding_depth;
 577   indent ();
 578   fprintf (stderr, "push %s level 0x%08x line %d\n",
 579            (is_class_level) ? "class" : "block", newlevel, lineno);
 580   is_class_level = 0;
 581   binding_depth++;
 582 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 583 }
 584
 585 /* Find the innermost enclosing class scope, and reset
 586    CLASS_BINDING_LEVEL appropriately.  */
 587
 588 static void
 589 find_class_binding_level ()
 590 {
 591   struct binding_level *level = current_binding_level;
 592
 593   while (level && level->parm_flag != 2)
 594     level = level->level_chain;
 595   if (level && level->parm_flag == 2)
 596     class_binding_level = level;
 597   else
 598     class_binding_level = 0;
 599 }
 600
 601 static void
 602 pop_binding_level ()
 603 {
 604   if (global_binding_level)
 605     {
 606       /* Cannot pop a level, if there are none left to pop.  */
 607       if (current_binding_level == global_binding_level)
 608         my_friendly_abort (123);
 609     }
 610   /* Pop the current level, and free the structure for reuse.  */
 611 #if defined(DEBUG_CP_BINDING_LEVELS)
 612   binding_depth--;
 613   indent ();
 614   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 615           (is_class_level) ? "class" : "block",
 616           current_binding_level, lineno);
 617   if (is_class_level != (current_binding_level == class_binding_level))
 618     {
 619       indent ();
 620       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 621     }
 622   is_class_level = 0;
 623 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 624   {
 625     register struct binding_level *level = current_binding_level;
 626     current_binding_level = current_binding_level->level_chain;
 627     level->level_chain = free_binding_level;
 628 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 629     if (level->binding_depth != binding_depth)
 630       abort ();
 631 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 632     free_binding_level = level;
 633     find_class_binding_level ();
 634   }
 635 }
 636
 637 static void
 638 suspend_binding_level ()
 639 {
 640   if (class_binding_level)
 641     current_binding_level = class_binding_level;
 642
 643   if (global_binding_level)
 644     {
 645       /* Cannot suspend a level, if there are none left to suspend.  */
 646       if (current_binding_level == global_binding_level)
 647         my_friendly_abort (123);
 648     }
 649   /* Suspend the current level.  */
 650 #if defined(DEBUG_CP_BINDING_LEVELS)
 651   binding_depth--;
 652   indent ();
 653   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 654           (is_class_level) ? "class" : "block",
 655           current_binding_level, lineno);
 656   if (is_class_level != (current_binding_level == class_binding_level))
 657     {
 658       indent ();
 659       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 660     }
 661   is_class_level = 0;
 662 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 663   current_binding_level = current_binding_level->level_chain;
 664   find_class_binding_level ();
 665 }
 666
 667 static void
 668 resume_binding_level (b)
 669      struct binding_level *b;
 670 {
 671   /* Resuming binding levels is meant only for namespaces,
 672      and those cannot nest into classes. */
 673   my_friendly_assert(!class_binding_level, 386);
 674   /* Also, resuming a non-directly nested namespace is a no-no.  */
 675   my_friendly_assert(b->level_chain == current_binding_level, 386);
 676   current_binding_level = b;
 677 #if defined(DEBUG_CP_BINDING_LEVELS)
 678   b->binding_depth = binding_depth;
 679   indent ();
 680   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 681            (is_class_level) ? "class" : "block", b, lineno);
 682   is_class_level = 0;
 683   binding_depth++;
 684 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 685 }
 686 \f
 687 /* Create a new `struct binding_level'.  */
 688
 689 static
 690 struct binding_level *
 691 make_binding_level ()
 692 {
 693   /* NOSTRICT */
 694   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 695 }
 696
 697 /* Nonzero if we are currently in the global binding level.  */
 698
 699 int
 700 global_bindings_p ()
 701 {
 702   return current_binding_level == global_binding_level;
 703 }
 704
 705 /* Return the innermost binding level that is not for a class scope.  */
 706
 707 static struct binding_level *
 708 innermost_nonclass_level ()
 709 {
 710   struct binding_level *b;
 711
 712   b = current_binding_level;
 713   while (b->parm_flag == 2)
 714     b = b->level_chain;
 715
 716   return b;
 717 }
 718
 719 /* Nonzero if we are currently in a toplevel binding level.  This
 720    means either the global binding level or a namespace in a toplevel
 721    binding level.  Since there are no non-toplevel namespace levels,
 722    this really means any namespace or template parameter level.  We
 723    also include a class whose context is toplevel.  */
 724
 725 int
 726 toplevel_bindings_p ()
 727 {
 728   struct binding_level *b = innermost_nonclass_level ();
 729
 730   return b->namespace_p || b->template_parms_p;
 731 }
 732
 733 /* Nonzero if this is a namespace scope, or if we are defining a class
 734    which is itself at namespace scope, or whose enclosing class is
 735    such a class, etc.  */
 736
 737 int
 738 namespace_bindings_p ()
 739 {
 740   struct binding_level *b = innermost_nonclass_level ();
 741
 742   return b->namespace_p;
 743 }
 744
 745 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 746    unconditionally.  Otherwise, use the normal logic to decide whether
 747    or not to create a BLOCK.  */
 748
 749 void
 750 keep_next_level (keep)
 751      int keep;
 752 {
 753   keep_next_level_flag = keep;
 754 }
 755
 756 /* Nonzero if the current level needs to have a BLOCK made.  */
 757
 758 int
 759 kept_level_p ()
 760 {
 761   return (current_binding_level->blocks != NULL_TREE
 762           || current_binding_level->keep
 763           || current_binding_level->names != NULL_TREE
 764           || (current_binding_level->tags != NULL_TREE
 765               && !current_binding_level->tag_transparent));
 766 }
 767
 768 static void
 769 declare_namespace_level ()
 770 {
 771   current_binding_level->namespace_p = 1;
 772 }
 773
 774 /* Returns non-zero if this scope was created to store template
 775    parameters.  */
 776
 777 int
 778 template_parm_scope_p ()
 779 {
 780   return current_binding_level->template_parms_p;
 781 }
 782
 783 /* Returns the kind of template specialization we are currently
 784    processing, given that it's declaration contained N_CLASS_SCOPES
 785    explicit scope qualifications.  */
 786
 787 tmpl_spec_kind
 788 current_tmpl_spec_kind (n_class_scopes)
 789      int n_class_scopes;
 790 {
 791   int n_template_parm_scopes = 0;
 792   int seen_specialization_p = 0;
 793   int innermost_specialization_p = 0;
 794   struct binding_level *b;
 795
 796   /* Scan through the template parameter scopes.  */
 797   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 798     {
 799       /* If we see a specialization scope inside a parameter scope,
 800          then something is wrong.  That corresponds to a declaration
 801          like:
 802
 803             template <class T> template <> ...
 804
 805          which is always illegal since [temp.expl.spec] forbids the
 806          specialization of a class member template if the enclosing
 807          class templates are not explicitly specialized as well.  */
 808       if (b->template_spec_p)
 809         {
 810           if (n_template_parm_scopes == 0)
 811             innermost_specialization_p = 1;
 812           else
 813             seen_specialization_p = 1;
 814         }
 815       else if (seen_specialization_p == 1)
 816         return tsk_invalid_member_spec;
 817
 818       ++n_template_parm_scopes;
 819     }
 820
 821   /* Handle explicit instantiations.  */
 822   if (processing_explicit_instantiation)
 823     {
 824       if (n_template_parm_scopes != 0)
 825         /* We've seen a template parameter list during an explicit
 826            instantiation.  For example:
 827
 828              template <class T> template void f(int);
 829
 830            This is erroneous.  */
 831         return tsk_invalid_expl_inst;
 832       else
 833         return tsk_expl_inst;
 834     }
 835
 836   if (n_template_parm_scopes < n_class_scopes)
 837     /* We've not seen enough template headers to match all the
 838        specialized classes present.  For example:
 839
 840          template <class T> void R<T>::S<T>::f(int);
 841
 842        This is illegal; there needs to be one set of template
 843        parameters for each class.  */
 844     return tsk_insufficient_parms;
 845   else if (n_template_parm_scopes == n_class_scopes)
 846     /* We're processing a non-template declaration (even though it may
 847        be a member of a template class.)  For example:
 848
 849          template <class T> void S<T>::f(int);
 850
 851        The `class T' maches the `S<T>', leaving no template headers
 852        corresponding to the `f'.  */
 853     return tsk_none;
 854   else if (n_template_parm_scopes > n_class_scopes + 1)
 855     /* We've got too many template headers.  For example:
 856
 857          template <> template <class T> void f (T);
 858
 859        There need to be more enclosing classes.  */
 860     return tsk_excessive_parms;
 861   else
 862     /* This must be a template.  It's of the form:
 863
 864          template <class T> template <class U> void S<T>::f(U);
 865
 866        This is a specialization if the innermost level was a
 867        specialization; otherwise it's just a definition of the
 868        template.  */
 869     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 870 }
 871
 872 void
 873 set_class_shadows (shadows)
 874      tree shadows;
 875 {
 876   class_binding_level->class_shadowed = shadows;
 877 }
 878
 879 /* Enter a new binding level.
 880    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 881    not for that of tags.  */
 882
 883 void
 884 pushlevel (tag_transparent)
 885      int tag_transparent;
 886 {
 887   struct binding_level *newlevel;
 888
 889   if (cfun && !doing_semantic_analysis_p ())
 890     return;
 891
 892   /* Reuse or create a struct for this binding level.  */
 893 #if defined(DEBUG_CP_BINDING_LEVELS)
 894   if (0)
 895 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 896   if (free_binding_level)
 897 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 898     {
 899       newlevel = free_binding_level;
 900       free_binding_level = free_binding_level->level_chain;
 901     }
 902   else
 903     newlevel = make_binding_level ();
 904
 905   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 906   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 907   keep_next_level_flag = 0;
 908 }
 909
 910 /* Enter a new scope.  The KIND indicates what kind of scope is being
 911    created.  */
 912
 913 void
 914 begin_scope (sk)
 915      scope_kind sk;
 916 {
 917   pushlevel (0);
 918
 919   switch (sk)
 920     {
 921     case sk_template_spec:
 922       current_binding_level->template_spec_p = 1;
 923       /* Fall through.  */
 924
 925     case sk_template_parms:
 926       current_binding_level->template_parms_p = 1;
 927       break;
 928
 929     default:
 930       my_friendly_abort (20000309);
 931     }
 932 }
 933
 934 /* Exit the current scope.  */
 935
 936 void
 937 finish_scope ()
 938 {
 939   poplevel (0, 0, 0);
 940 }
 941
 942 void
 943 note_level_for_for ()
 944 {
 945   current_binding_level->is_for_scope = 1;
 946 }
 947
 948 /* Record that the current binding level represents a try block.  */
 949
 950 void
 951 note_level_for_eh ()
 952 {
 953   current_binding_level->eh_region = 1;
 954 }
 955
 956 /* For a binding between a name and an entity at a block scope,
 957    this is the `struct binding_level' for the block.  */
 958 #define BINDING_LEVEL(NODE) \
 959    (((struct tree_binding*)NODE)->scope.level)
 960
 961 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 962    level at which this declaration is being bound.  */
 963
 964 static void
 965 push_binding (id, decl, level)
 966      tree id;
 967      tree decl;
 968      struct binding_level* level;
 969 {
 970   tree binding;
 971
 972   binding = make_node (CPLUS_BINDING);
 973
 974   /* Now, fill in the binding information.  */
 975   BINDING_VALUE (binding) = decl;
 976   BINDING_TYPE (binding) = NULL_TREE;
 977   BINDING_LEVEL (binding) = level;
 978   INHERITED_VALUE_BINDING_P (binding) = 0;
 979   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 980   BINDING_HAS_LEVEL_P (binding) = 1;
 981
 982   /* And put it on the front of the list of bindings for ID.  */
 983   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 984   IDENTIFIER_BINDING (id) = binding;
 985 }
 986
 987 /* ID is already bound in the current scope.  But, DECL is an
 988    additional binding for ID in the same scope.  This is the `struct
 989    stat' hack whereby a non-typedef class-name or enum-name can be
 990    bound at the same level as some other kind of entity.  It's the
 991    responsibility of the caller to check that inserting this name is
 992    legal here.  Returns nonzero if the new binding was successful.  */
 993 static int
 994 add_binding (id, decl)
 995      tree id;
 996      tree decl;
 997 {
 998   tree binding = IDENTIFIER_BINDING (id);
 999   int ok = 1;
1000
1001   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1002     /* The new name is the type name.  */
1003     BINDING_TYPE (binding) = decl;
1004   else if (!BINDING_VALUE (binding))
1005     /* This situation arises when push_class_level_binding moves an
1006        inherited type-binding out of the way to make room for a new
1007        value binding.  */
1008     BINDING_VALUE (binding) = decl;
1009   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1010            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1011     {
1012       /* The old binding was a type name.  It was placed in
1013          BINDING_VALUE because it was thought, at the point it was
1014          declared, to be the only entity with such a name.  Move the
1015          type name into the type slot; it is now hidden by the new
1016          binding.  */
1017       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1018       BINDING_VALUE (binding) = decl;
1019       INHERITED_VALUE_BINDING_P (binding) = 0;
1020     }
1021   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1022            && TREE_CODE (decl) == TYPE_DECL
1023            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1024            && same_type_p (TREE_TYPE (decl),
1025                            TREE_TYPE (BINDING_VALUE (binding))))
1026     /* We have two typedef-names, both naming the same type to have
1027        the same name.  This is OK because of:
1028
1029          [dcl.typedef]
1030
1031          In a given scope, a typedef specifier can be used to redefine
1032          the name of any type declared in that scope to refer to the
1033          type to which it already refers.  */
1034     ok = 0;
1035   else
1036     {
1037       cp_error ("declaration of `%#D'", decl);
1038       cp_error_at ("conflicts with previous declaration `%#D'",
1039                    BINDING_VALUE (binding));
1040       ok = 0;
1041     }
1042
1043   return ok;
1044 }
1045
1046 /* Add DECL to the list of things declared in B.  */
1047
1048 static void
1049 add_decl_to_level (decl, b)
1050      tree decl;
1051      struct binding_level *b;
1052 {
1053   /* We build up the list in reverse order, and reverse it later if
1054      necessary.  */
1055   TREE_CHAIN (decl) = b->names;
1056   b->names = decl;
1057 }
1058
1059 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1060    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1061    doesn't really belong to this binding level, that it got here
1062    through a using-declaration.  */
1063
1064 void
1065 push_local_binding (id, decl, flags)
1066      tree id;
1067      tree decl;
1068      int flags;
1069 {
1070   struct binding_level *b;
1071
1072   /* Skip over any local classes.  This makes sense if we call
1073      push_local_binding with a friend decl of a local class.  */
1074   b = current_binding_level;
1075   while (b->parm_flag == 2)
1076     b = b->level_chain;
1077
1078   if (lookup_name_current_level (id))
1079     {
1080       /* Supplement the existing binding.  */
1081       if (!add_binding (id, decl))
1082         /* It didn't work.  Something else must be bound at this
1083            level.  Do not add DECL to the list of things to pop
1084            later.  */
1085         return;
1086     }
1087   else
1088     /* Create a new binding.  */
1089     push_binding (id, decl, b);
1090
1091   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1092     /* We must put the OVERLOAD into a TREE_LIST since the
1093        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1094        decls that got here through a using-declaration.  */
1095     decl = build_tree_list (NULL_TREE, decl);
1096
1097   /* And put DECL on the list of things declared by the current
1098      binding level.  */
1099   add_decl_to_level (decl, b);
1100 }
1101
1102 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1103    binding was successful.  */
1104
1105 int
1106 push_class_binding (id, decl)
1107      tree id;
1108      tree decl;
1109 {
1110   int result = 1;
1111   tree binding = IDENTIFIER_BINDING (id);
1112   tree context;
1113
1114   /* Note that we declared this value so that we can issue an error if
1115      this an illegal redeclaration of a name already used for some
1116      other purpose.  */
1117   note_name_declared_in_class (id, decl);
1118
1119   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1120     /* Supplement the existing binding.  */
1121     result = add_binding (id, decl);
1122   else
1123     /* Create a new binding.  */
1124     push_binding (id, decl, class_binding_level);
1125
1126   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1127      class-level declaration.  Note that we do not use DECL here
1128      because of the possibility of the `struct stat' hack; if DECL is
1129      a class-name or enum-name we might prefer a field-name, or some
1130      such.  */
1131   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1132
1133   /* If this is a binding from a base class, mark it as such.  */
1134   binding = IDENTIFIER_BINDING (id);
1135   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1136     {
1137       /* Any implicit typename must be from a base-class.  The
1138          context for an implicit typename declaration is always
1139          the derived class in which the lookup was done, so the checks
1140          based on the context of DECL below will not trigger.  */
1141       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1142         INHERITED_VALUE_BINDING_P (binding) = 1;
1143       else
1144         {
1145           if (TREE_CODE (decl) == OVERLOAD)
1146             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1147           else
1148             {
1149               my_friendly_assert (DECL_P (decl), 0);
1150               context = CP_DECL_CONTEXT (decl);
1151             }
1152
1153           if (is_properly_derived_from (current_class_type, context))
1154             INHERITED_VALUE_BINDING_P (binding) = 1;
1155           else
1156             INHERITED_VALUE_BINDING_P (binding) = 0;
1157         }
1158     }
1159   else if (BINDING_VALUE (binding) == decl)
1160     /* We only encounter a TREE_LIST when push_class_decls detects an
1161        ambiguity.  Such an ambiguity can be overridden by a definition
1162        in this class.  */
1163     INHERITED_VALUE_BINDING_P (binding) = 1;
1164
1165   return result;
1166 }
1167
1168 /* Remove the binding for DECL which should be the innermost binding
1169    for ID.  */
1170
1171 static void
1172 pop_binding (id, decl)
1173      tree id;
1174      tree decl;
1175 {
1176   tree binding;
1177
1178   if (id == NULL_TREE)
1179     /* It's easiest to write the loops that call this function without
1180        checking whether or not the entities involved have names.  We
1181        get here for such an entity.  */
1182     return;
1183
1184   /* Get the innermost binding for ID.  */
1185   binding = IDENTIFIER_BINDING (id);
1186
1187   /* The name should be bound.  */
1188   my_friendly_assert (binding != NULL_TREE, 0);
1189
1190   /* The DECL will be either the ordinary binding or the type
1191      binding for this identifier.  Remove that binding.  */
1192   if (BINDING_VALUE (binding) == decl)
1193     BINDING_VALUE (binding) = NULL_TREE;
1194   else if (BINDING_TYPE (binding) == decl)
1195     BINDING_TYPE (binding) = NULL_TREE;
1196   else
1197     my_friendly_abort (0);
1198
1199   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1200     /* We're completely done with the innermost binding for this
1201        identifier.  Unhook it from the list of bindings.  */
1202     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1203 }
1204
1205 /* When a label goes out of scope, check to see if that label was used
1206    in a valid manner, and issue any appropriate warnings or errors.  */
1207
1208 static void
1209 pop_label (label, old_value)
1210      tree label;
1211      tree old_value;
1212 {
1213   if (!processing_template_decl && doing_semantic_analysis_p ())
1214     {
1215       if (DECL_INITIAL (label) == NULL_TREE)
1216         {
1217           cp_error_at ("label `%D' used but not defined", label);
1218           /* Avoid crashing later.  */
1219           define_label (input_filename, 1, DECL_NAME (label));
1220         }
1221       else if (warn_unused_label && !TREE_USED (label))
1222         cp_warning_at ("label `%D' defined but not used", label);
1223     }
1224
1225   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1226 }
1227
1228 /* At the end of a function, all labels declared within the fucntion
1229    go out of scope.  BLOCK is the top-level block for the
1230    function.  */
1231
1232 static void
1233 pop_labels (block)
1234      tree block;
1235 {
1236   struct named_label_list *link;
1237
1238   /* Clear out the definitions of all label names, since their scopes
1239      end here.  */
1240   for (link = named_labels; link; link = link->next)
1241     {
1242       pop_label (link->label_decl, link->old_value);
1243       /* Put the labels into the "variables" of the top-level block,
1244          so debugger can see them.  */
1245       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1246       BLOCK_VARS (block) = link->label_decl;
1247     }
1248
1249   named_labels = NULL;
1250 }
1251
1252 /* Exit a binding level.
1253    Pop the level off, and restore the state of the identifier-decl mappings
1254    that were in effect when this level was entered.
1255
1256    If KEEP == 1, this level had explicit declarations, so
1257    and create a "block" (a BLOCK node) for the level
1258    to record its declarations and subblocks for symbol table output.
1259
1260    If FUNCTIONBODY is nonzero, this level is the body of a function,
1261    so create a block as if KEEP were set and also clear out all
1262    label names.
1263
1264    If REVERSE is nonzero, reverse the order of decls before putting
1265    them into the BLOCK.  */
1266
1267 tree
1268 poplevel (keep, reverse, functionbody)
1269      int keep;
1270      int reverse;
1271      int functionbody;
1272 {
1273   register tree link;
1274   /* The chain of decls was accumulated in reverse order.
1275      Put it into forward order, just for cleanliness.  */
1276   tree decls;
1277   int tmp = functionbody;
1278   int real_functionbody;
1279   tree tags;
1280   tree subblocks;
1281   tree block = NULL_TREE;
1282   tree decl;
1283   int block_previously_created;
1284   int leaving_for_scope;
1285
1286   if (cfun && !doing_semantic_analysis_p ())
1287     return NULL_TREE;
1288
1289   my_friendly_assert (current_binding_level->parm_flag != 2,
1290                       19990916);
1291
1292   real_functionbody = (current_binding_level->keep == 2
1293                        ? ((functionbody = 0), tmp) : functionbody);
1294   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1295   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1296
1297   my_friendly_assert (!current_binding_level->class_shadowed,
1298                       19990414);
1299
1300   /* We used to use KEEP == 2 to indicate that the new block should go
1301      at the beginning of the list of blocks at this binding level,
1302      rather than the end.  This hack is no longer used.  */
1303   my_friendly_assert (keep == 0 || keep == 1, 0);
1304
1305   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1306                       (HOST_WIDE_INT) current_binding_level->level_chain,
1307                       current_binding_level->parm_flag,
1308                       current_binding_level->keep);
1309
1310   if (current_binding_level->keep == 1)
1311     keep = 1;
1312
1313   /* Any uses of undefined labels, and any defined labels, now operate
1314      under constraints of next binding contour.  */
1315   if (cfun && !functionbody)
1316     {
1317       struct binding_level *level_chain;
1318       level_chain = current_binding_level->level_chain;
1319       if (level_chain)
1320         {
1321           struct named_label_use_list *uses;
1322           struct named_label_list *labels;
1323           for (labels = named_labels; labels; labels = labels->next)
1324             if (labels->binding_level == current_binding_level)
1325               {
1326                 tree decl;
1327                 if (current_binding_level->eh_region)
1328                   labels->eh_region = 1;
1329                 for (decl = labels->names_in_scope; decl;
1330                      decl = TREE_CHAIN (decl))
1331                   if (decl_jump_unsafe (decl))
1332                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1333                                                    labels->bad_decls);
1334                 labels->binding_level = level_chain;
1335                 labels->names_in_scope = level_chain->names;
1336               }
1337
1338           for (uses = named_label_uses; uses; uses = uses->next)
1339             if (uses->binding_level == current_binding_level)
1340               {
1341                 uses->binding_level = level_chain;
1342                 uses->names_in_scope = level_chain->names;
1343               }
1344         }
1345     }
1346
1347   /* Get the decls in the order they were written.
1348      Usually current_binding_level->names is in reverse order.
1349      But parameter decls were previously put in forward order.  */
1350
1351   if (reverse)
1352     current_binding_level->names
1353       = decls = nreverse (current_binding_level->names);
1354   else
1355     decls = current_binding_level->names;
1356
1357   /* Output any nested inline functions within this block
1358      if they weren't already output.  */
1359   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1360     if (TREE_CODE (decl) == FUNCTION_DECL
1361         && ! TREE_ASM_WRITTEN (decl)
1362         && DECL_INITIAL (decl) != NULL_TREE
1363         && TREE_ADDRESSABLE (decl)
1364         && decl_function_context (decl) == current_function_decl)
1365       {
1366         /* If this decl was copied from a file-scope decl
1367            on account of a block-scope extern decl,
1368            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1369         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1370           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1371         else
1372           {
1373             push_function_context ();
1374             output_inline_function (decl);
1375             pop_function_context ();
1376           }
1377       }
1378
1379   /* When not in function-at-a-time mode, expand_end_bindings will
1380      warn about unused variables.  But, in function-at-a-time mode
1381      expand_end_bindings is not passed the list of variables in the
1382      current scope, and therefore no warning is emitted.  So, we
1383      explicitly warn here.  */
1384   if (!processing_template_decl)
1385     warn_about_unused_variables (getdecls ());
1386
1387   /* If there were any declarations or structure tags in that level,
1388      or if this level is a function body,
1389      create a BLOCK to record them for the life of this function.  */
1390   block = NULL_TREE;
1391   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1392   if (block_previously_created)
1393     block = current_binding_level->this_block;
1394   else if (keep == 1 || functionbody)
1395     block = make_node (BLOCK);
1396   if (block != NULL_TREE)
1397     {
1398       if (block_previously_created)
1399         {
1400           if (decls || tags || subblocks)
1401             {
1402               if (BLOCK_VARS (block))
1403                 warning ("internal compiler error: debugging info corrupted");
1404
1405               BLOCK_VARS (block) = decls;
1406
1407               /* We can have previous subblocks and new subblocks when
1408                  doing fixup_gotos with complex cleanups.  We chain the new
1409                  subblocks onto the end of any pre-existing subblocks.  */
1410               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1411                                                  subblocks);
1412             }
1413         }
1414       else
1415         {
1416           BLOCK_VARS (block) = decls;
1417           BLOCK_SUBBLOCKS (block) = subblocks;
1418         }
1419     }
1420
1421   /* In each subblock, record that this is its superior.  */
1422   if (keep >= 0)
1423     for (link = subblocks; link; link = TREE_CHAIN (link))
1424       BLOCK_SUPERCONTEXT (link) = block;
1425
1426   /* We still support the old for-scope rules, whereby the variables
1427      in a for-init statement were in scope after the for-statement
1428      ended.  We only use the new rules in flag_new_for_scope is
1429      nonzero.  */
1430   leaving_for_scope
1431     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1432
1433   /* Remove declarations for all the DECLs in this level.  */
1434   for (link = decls; link; link = TREE_CHAIN (link))
1435     {
1436       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1437         {
1438           tree outer_binding
1439             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1440           tree ns_binding;
1441
1442           if (!outer_binding)
1443             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1444           else
1445             ns_binding = NULL_TREE;
1446
1447           if (outer_binding
1448               && (BINDING_LEVEL (outer_binding)
1449                   == current_binding_level->level_chain))
1450             /* We have something like:
1451
1452                  int i;
1453                  for (int i; ;);
1454
1455                and we are leaving the `for' scope.  There's no reason to
1456                keep the binding of the inner `i' in this case.  */
1457             pop_binding (DECL_NAME (link), link);
1458           else if ((outer_binding
1459                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1460                         == TYPE_DECL))
1461                    || (ns_binding
1462                        && TREE_CODE (ns_binding) == TYPE_DECL))
1463             /* Here, we have something like:
1464
1465                  typedef int I;
1466
1467                  void f () {
1468                    for (int I; ;);
1469                  }
1470
1471                We must pop the for-scope binding so we know what's a
1472                type and what isn't.  */
1473             pop_binding (DECL_NAME (link), link);
1474           else
1475             {
1476               /* Mark this VAR_DECL as dead so that we can tell we left it
1477                  there only for backward compatibility.  */
1478               DECL_DEAD_FOR_LOCAL (link) = 1;
1479
1480               /* Keep track of what should of have happenned when we
1481                  popped the binding.  */
1482               if (outer_binding && BINDING_VALUE (outer_binding))
1483                 DECL_SHADOWED_FOR_VAR (link)
1484                   = BINDING_VALUE (outer_binding);
1485
1486               /* Add it to the list of dead variables in the next
1487                  outermost binding to that we can remove these when we
1488                  leave that binding.  */
1489               current_binding_level->level_chain->dead_vars_from_for
1490                 = tree_cons (NULL_TREE, link,
1491                              current_binding_level->level_chain->
1492                              dead_vars_from_for);
1493
1494               /* Although we don't pop the CPLUS_BINDING, we do clear
1495                  its BINDING_LEVEL since the level is going away now.  */
1496               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1497                 = 0;
1498             }
1499         }
1500       else
1501         {
1502           /* Remove the binding.  */
1503           decl = link;
1504           if (TREE_CODE (decl) == TREE_LIST)
1505             decl = TREE_VALUE (decl);
1506           if (DECL_P (decl))
1507             pop_binding (DECL_NAME (decl), decl);
1508           else if (TREE_CODE (decl) == OVERLOAD)
1509             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1510           else
1511             my_friendly_abort (0);
1512         }
1513     }
1514
1515   /* Remove declarations for any `for' variables from inner scopes
1516      that we kept around.  */
1517   for (link = current_binding_level->dead_vars_from_for;
1518        link; link = TREE_CHAIN (link))
1519     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1520
1521   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1522   for (link = current_binding_level->type_shadowed;
1523        link; link = TREE_CHAIN (link))
1524     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1525
1526   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1527   for (link = current_binding_level->shadowed_labels;
1528        link;
1529        link = TREE_CHAIN (link))
1530     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1531
1532   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1533      list if a `using' declaration put them there.  The debugging
1534      back-ends won't understand OVERLOAD, so we remove them here.
1535      Because the BLOCK_VARS are (temporarily) shared with
1536      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1537      popped all the bindings.  */
1538   if (block)
1539     {
1540       tree* d;
1541
1542       for (d = &BLOCK_VARS (block); *d; )
1543         {
1544           if (TREE_CODE (*d) == TREE_LIST)
1545             *d = TREE_CHAIN (*d);
1546           else
1547             d = &TREE_CHAIN (*d);
1548         }
1549     }
1550
1551   /* If the level being exited is the top level of a function,
1552      check over all the labels.  */
1553   if (functionbody)
1554     {
1555       /* Since this is the top level block of a function, the vars are
1556          the function's parameters.  Don't leave them in the BLOCK
1557          because they are found in the FUNCTION_DECL instead.  */
1558       BLOCK_VARS (block) = 0;
1559       pop_labels (block);
1560     }
1561
1562   tmp = current_binding_level->keep;
1563
1564   pop_binding_level ();
1565   if (functionbody)
1566     DECL_INITIAL (current_function_decl) = block;
1567   else if (block)
1568     {
1569       if (!block_previously_created)
1570         current_binding_level->blocks
1571           = chainon (current_binding_level->blocks, block);
1572     }
1573   /* If we did not make a block for the level just exited,
1574      any blocks made for inner levels
1575      (since they cannot be recorded as subblocks in that level)
1576      must be carried forward so they will later become subblocks
1577      of something else.  */
1578   else if (subblocks)
1579     current_binding_level->blocks
1580       = chainon (current_binding_level->blocks, subblocks);
1581
1582   /* Each and every BLOCK node created here in `poplevel' is important
1583      (e.g. for proper debugging information) so if we created one
1584      earlier, mark it as "used".  */
1585   if (block)
1586     TREE_USED (block) = 1;
1587
1588   /* Take care of compiler's internal binding structures.  */
1589   if (tmp == 2)
1590     {
1591       tree scope_stmts;
1592
1593       scope_stmts
1594         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1595       if (block)
1596         {
1597           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1598           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1599         }
1600
1601       block = poplevel (keep, reverse, functionbody);
1602     }
1603
1604   return block;
1605 }
1606
1607 /* Delete the node BLOCK from the current binding level.
1608    This is used for the block inside a stmt expr ({...})
1609    so that the block can be reinserted where appropriate.  */
1610
1611 void
1612 delete_block (block)
1613      tree block;
1614 {
1615   tree t;
1616   if (current_binding_level->blocks == block)
1617     current_binding_level->blocks = TREE_CHAIN (block);
1618   for (t = current_binding_level->blocks; t;)
1619     {
1620       if (TREE_CHAIN (t) == block)
1621         TREE_CHAIN (t) = TREE_CHAIN (block);
1622       else
1623         t = TREE_CHAIN (t);
1624     }
1625   TREE_CHAIN (block) = NULL_TREE;
1626   /* Clear TREE_USED which is always set by poplevel.
1627      The flag is set again if insert_block is called.  */
1628   TREE_USED (block) = 0;
1629 }
1630
1631 /* Insert BLOCK at the end of the list of subblocks of the
1632    current binding level.  This is used when a BIND_EXPR is expanded,
1633    to handle the BLOCK node inside the BIND_EXPR.  */
1634
1635 void
1636 insert_block (block)
1637      tree block;
1638 {
1639   TREE_USED (block) = 1;
1640   current_binding_level->blocks
1641     = chainon (current_binding_level->blocks, block);
1642 }
1643
1644 /* Set the BLOCK node for the innermost scope
1645    (the one we are currently in).  */
1646
1647 void
1648 set_block (block)
1649     register tree block;
1650 {
1651   current_binding_level->this_block = block;
1652 }
1653
1654 /* Do a pushlevel for class declarations.  */
1655
1656 void
1657 pushlevel_class ()
1658 {
1659   register struct binding_level *newlevel;
1660
1661   /* Reuse or create a struct for this binding level.  */
1662 #if defined(DEBUG_CP_BINDING_LEVELS)
1663   if (0)
1664 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1665   if (free_binding_level)
1666 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1667     {
1668       newlevel = free_binding_level;
1669       free_binding_level = free_binding_level->level_chain;
1670     }
1671   else
1672     newlevel = make_binding_level ();
1673
1674 #if defined(DEBUG_CP_BINDING_LEVELS)
1675   is_class_level = 1;
1676 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1677
1678   push_binding_level (newlevel, 0, 0);
1679
1680   class_binding_level = current_binding_level;
1681   class_binding_level->parm_flag = 2;
1682   class_binding_level->this_class = current_class_type;
1683 }
1684
1685 /* ...and a poplevel for class declarations.  */
1686
1687 void
1688 poplevel_class ()
1689 {
1690   register struct binding_level *level = class_binding_level;
1691   tree shadowed;
1692
1693   my_friendly_assert (level != 0, 354);
1694
1695   /* If we're leaving a toplevel class, don't bother to do the setting
1696      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1697      shouldn't even be used when current_class_type isn't set, and second,
1698      if we don't touch it here, we're able to use the cache effect if the
1699      next time we're entering a class scope, it is the same class.  */
1700   if (current_class_depth != 1)
1701     {
1702       struct binding_level* b;
1703
1704       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1705       for (shadowed = level->class_shadowed;
1706            shadowed;
1707            shadowed = TREE_CHAIN (shadowed))
1708         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1709
1710       /* Find the next enclosing class, and recreate
1711          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1712       b = level->level_chain;
1713       while (b && b->parm_flag != 2)
1714         b = b->level_chain;
1715
1716       if (b)
1717         for (shadowed = b->class_shadowed;
1718              shadowed;
1719              shadowed = TREE_CHAIN (shadowed))
1720           {
1721             tree t;
1722
1723             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1724             while (t && BINDING_LEVEL (t) != b)
1725               t = TREE_CHAIN (t);
1726
1727             if (t)
1728               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1729                 = BINDING_VALUE (t);
1730           }
1731     }
1732   else
1733     /* Remember to save what IDENTIFIER's were bound in this scope so we
1734        can recover from cache misses.  */
1735     {
1736       previous_class_type = current_class_type;
1737       previous_class_values = class_binding_level->class_shadowed;
1738     }
1739   for (shadowed = level->type_shadowed;
1740        shadowed;
1741        shadowed = TREE_CHAIN (shadowed))
1742     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1743
1744   /* Remove the bindings for all of the class-level declarations.  */
1745   for (shadowed = level->class_shadowed;
1746        shadowed;
1747        shadowed = TREE_CHAIN (shadowed))
1748     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1749
1750   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1751                       (HOST_WIDE_INT) class_binding_level->level_chain,
1752                       class_binding_level->parm_flag,
1753                       class_binding_level->keep);
1754
1755   /* Now, pop out of the binding level which we created up in the
1756      `pushlevel_class' routine.  */
1757 #if defined(DEBUG_CP_BINDING_LEVELS)
1758   is_class_level = 1;
1759 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1760
1761   pop_binding_level ();
1762 }
1763
1764 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1765    for any names in enclosing classes.  */
1766
1767 void
1768 clear_identifier_class_values ()
1769 {
1770   tree t;
1771
1772   if (!class_binding_level)
1773     return;
1774
1775   for (t = class_binding_level->class_shadowed;
1776        t;
1777        t = TREE_CHAIN (t))
1778     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1779 }
1780
1781 /* Returns non-zero if T is a virtual function table.  */
1782
1783 int
1784 vtable_decl_p (t, data)
1785      tree t;
1786      void *data ATTRIBUTE_UNUSED;
1787 {
1788   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1789 }
1790
1791 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1792    functions.  */
1793
1794 int
1795 vtype_decl_p (t, data)
1796      tree t;
1797      void *data ATTRIBUTE_UNUSED;
1798 {
1799   return (TREE_CODE (t) == TYPE_DECL
1800           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1801           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1802 }
1803
1804 /* Return the declarations that are members of the namespace NS.  */
1805
1806 tree
1807 cp_namespace_decls (ns)
1808      tree ns;
1809 {
1810   return NAMESPACE_LEVEL (ns)->names;
1811 }
1812
1813 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1814    itself, calling F for each.  The DATA is passed to F as well.  */
1815
1816 static int
1817 walk_namespaces_r (namespace, f, data)
1818      tree namespace;
1819      walk_namespaces_fn f;
1820      void *data;
1821 {
1822   tree current;
1823   int result = 0;
1824
1825   result |= (*f) (namespace, data);
1826
1827   for (current = cp_namespace_decls (namespace);
1828        current;
1829        current = TREE_CHAIN (current))
1830     {
1831       if (TREE_CODE (current) != NAMESPACE_DECL
1832           || DECL_NAMESPACE_ALIAS (current))
1833         continue;
1834       if (!DECL_LANG_SPECIFIC (current))
1835         {
1836           /* Hmm. std. */
1837           my_friendly_assert (current == std_node, 393);
1838           continue;
1839         }
1840
1841       /* We found a namespace.  */
1842       result |= walk_namespaces_r (current, f, data);
1843     }
1844
1845   return result;
1846 }
1847
1848 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1849    F as well.  */
1850
1851 int
1852 walk_namespaces (f, data)
1853      walk_namespaces_fn f;
1854      void *data;
1855 {
1856   return walk_namespaces_r (global_namespace, f, data);
1857 }
1858
1859 struct walk_globals_data {
1860   walk_globals_pred p;
1861   walk_globals_fn f;
1862   void *data;
1863 };
1864
1865 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1866    for which P returns non-zero, call F with its address.  If any call
1867    to F returns a non-zero value, return a non-zero value.  */
1868
1869 static int
1870 walk_globals_r (namespace, data)
1871      tree namespace;
1872      void *data;
1873 {
1874   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1875   walk_globals_pred p = wgd->p;
1876   walk_globals_fn f = wgd->f;
1877   void *d = wgd->data;
1878   tree *t;
1879   int result = 0;
1880
1881   t = &NAMESPACE_LEVEL (namespace)->names;
1882
1883   while (*t)
1884     {
1885       tree glbl = *t;
1886
1887       if ((*p) (glbl, d))
1888         result |= (*f) (t, d);
1889
1890       /* If F changed *T, then *T still points at the next item to
1891          examine.  */
1892       if (*t == glbl)
1893         t = &TREE_CHAIN (*t);
1894     }
1895
1896   return result;
1897 }
1898
1899 /* Walk the global declarations.  Whenever one is found for which P
1900    returns non-zero, call F with its address.  If any call to F
1901    returns a non-zero value, return a non-zero value.  */
1902
1903 int
1904 walk_globals (p, f, data)
1905      walk_globals_pred p;
1906      walk_globals_fn f;
1907      void *data;
1908 {
1909   struct walk_globals_data wgd;
1910   wgd.p = p;
1911   wgd.f = f;
1912   wgd.data = data;
1913
1914   return walk_namespaces (walk_globals_r, &wgd);
1915 }
1916
1917 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1918    DATA is non-NULL, this is the last time we will call
1919    wrapup_global_declarations for this NAMESPACE.  */
1920
1921 int
1922 wrapup_globals_for_namespace (namespace, data)
1923      tree namespace;
1924      void *data;
1925 {
1926   tree globals = cp_namespace_decls (namespace);
1927   int len = list_length (globals);
1928   tree *vec = (tree *) alloca (sizeof (tree) * len);
1929   int i;
1930   int result;
1931   tree decl;
1932   int last_time = (data != 0);
1933
1934   if (last_time && namespace == global_namespace)
1935     /* Let compile_file handle the global namespace.  */
1936     return 0;
1937
1938   /* Process the decls in reverse order--earliest first.
1939      Put them into VEC from back to front, then take out from front.  */
1940
1941   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1942     {
1943       /* Pretend we've output an unused static variable.  This ensures
1944          that the toplevel __FUNCTION__ etc won't be emitted, unless
1945          needed. */
1946       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1947           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1948         {
1949           TREE_ASM_WRITTEN (decl) = 1;
1950           DECL_IGNORED_P (decl) = 1;
1951         }
1952       vec[len - i - 1] = decl;
1953     }
1954
1955   if (last_time)
1956     {
1957       check_global_declarations (vec, len);
1958       return 0;
1959     }
1960
1961   /* Temporarily mark vtables as external.  That prevents
1962      wrapup_global_declarations from writing them out; we must process
1963      them ourselves in finish_vtable_vardecl.  */
1964   for (i = 0; i < len; ++i)
1965     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1966       {
1967         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1968         DECL_EXTERNAL (vec[i]) = 1;
1969       }
1970
1971   /* Write out any globals that need to be output.  */
1972   result = wrapup_global_declarations (vec, len);
1973
1974   /* Undo the hack to DECL_EXTERNAL above.  */
1975   for (i = 0; i < len; ++i)
1976     if (vtable_decl_p (vec[i], /*data=*/0)
1977         && DECL_NOT_REALLY_EXTERN (vec[i]))
1978       {
1979         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1980         DECL_EXTERNAL (vec[i]) = 0;
1981       }
1982
1983   return result;
1984 }
1985
1986 \f
1987 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1988
1989 static void
1990 mark_binding_level (arg)
1991      void *arg;
1992 {
1993   struct binding_level *lvl = *(struct binding_level **)arg;
1994
1995   for (; lvl; lvl = lvl->level_chain)
1996     {
1997       ggc_mark_tree (lvl->names);
1998       ggc_mark_tree (lvl->tags);
1999       ggc_mark_tree (lvl->usings);
2000       ggc_mark_tree (lvl->using_directives);
2001       ggc_mark_tree (lvl->class_shadowed);
2002       ggc_mark_tree (lvl->type_shadowed);
2003       ggc_mark_tree (lvl->shadowed_labels);
2004       ggc_mark_tree (lvl->blocks);
2005       ggc_mark_tree (lvl->this_block);
2006       ggc_mark_tree (lvl->this_class);
2007       ggc_mark_tree (lvl->incomplete);
2008       ggc_mark_tree (lvl->dead_vars_from_for);
2009     }
2010 }
2011
2012 static void
2013 mark_named_label_lists (labs, uses)
2014      void *labs;
2015      void *uses;
2016 {
2017   struct named_label_list *l = *(struct named_label_list **)labs;
2018   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2019
2020   for (; l; l = l->next)
2021     {
2022       ggc_mark (l);
2023       mark_binding_level (l->binding_level);
2024       ggc_mark_tree (l->old_value);
2025       ggc_mark_tree (l->label_decl);
2026       ggc_mark_tree (l->bad_decls);
2027     }
2028
2029   for (; u; u = u->next)
2030     ggc_mark (u);
2031 }
2032 \f
2033 /* For debugging.  */
2034 static int no_print_functions = 0;
2035 static int no_print_builtins = 0;
2036
2037 void
2038 print_binding_level (lvl)
2039      struct binding_level *lvl;
2040 {
2041   tree t;
2042   int i = 0, len;
2043   fprintf (stderr, " blocks=");
2044   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2045   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2046            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2047   if (lvl->tag_transparent)
2048     fprintf (stderr, " tag-transparent");
2049   if (lvl->more_cleanups_ok)
2050     fprintf (stderr, " more-cleanups-ok");
2051   if (lvl->have_cleanups)
2052     fprintf (stderr, " have-cleanups");
2053   fprintf (stderr, "\n");
2054   if (lvl->names)
2055     {
2056       fprintf (stderr, " names:\t");
2057       /* We can probably fit 3 names to a line?  */
2058       for (t = lvl->names; t; t = TREE_CHAIN (t))
2059         {
2060           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2061             continue;
2062           if (no_print_builtins
2063               && (TREE_CODE (t) == TYPE_DECL)
2064               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2065             continue;
2066
2067           /* Function decls tend to have longer names.  */
2068           if (TREE_CODE (t) == FUNCTION_DECL)
2069             len = 3;
2070           else
2071             len = 2;
2072           i += len;
2073           if (i > 6)
2074             {
2075               fprintf (stderr, "\n\t");
2076               i = len;
2077             }
2078           print_node_brief (stderr, "", t, 0);
2079           if (t == error_mark_node)
2080             break;
2081         }
2082       if (i)
2083         fprintf (stderr, "\n");
2084     }
2085   if (lvl->tags)
2086     {
2087       fprintf (stderr, " tags:\t");
2088       i = 0;
2089       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2090         {
2091           if (TREE_PURPOSE (t) == NULL_TREE)
2092             len = 3;
2093           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2094             len = 2;
2095           else
2096             len = 4;
2097           i += len;
2098           if (i > 5)
2099             {
2100               fprintf (stderr, "\n\t");
2101               i = len;
2102             }
2103           if (TREE_PURPOSE (t) == NULL_TREE)
2104             {
2105               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2106               fprintf (stderr, ">");
2107             }
2108           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2109             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2110           else
2111             {
2112               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2113               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2114               fprintf (stderr, ">");
2115             }
2116         }
2117       if (i)
2118         fprintf (stderr, "\n");
2119     }
2120   if (lvl->class_shadowed)
2121     {
2122       fprintf (stderr, " class-shadowed:");
2123       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2124         {
2125           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2126         }
2127       fprintf (stderr, "\n");
2128     }
2129   if (lvl->type_shadowed)
2130     {
2131       fprintf (stderr, " type-shadowed:");
2132       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2133         {
2134           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2135         }
2136       fprintf (stderr, "\n");
2137     }
2138 }
2139
2140 void
2141 print_other_binding_stack (stack)
2142      struct binding_level *stack;
2143 {
2144   struct binding_level *level;
2145   for (level = stack; level != global_binding_level; level = level->level_chain)
2146     {
2147       fprintf (stderr, "binding level ");
2148       fprintf (stderr, HOST_PTR_PRINTF, level);
2149       fprintf (stderr, "\n");
2150       print_binding_level (level);
2151     }
2152 }
2153
2154 void
2155 print_binding_stack ()
2156 {
2157   struct binding_level *b;
2158   fprintf (stderr, "current_binding_level=");
2159   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2160   fprintf (stderr, "\nclass_binding_level=");
2161   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2162   fprintf (stderr, "\nglobal_binding_level=");
2163   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2164   fprintf (stderr, "\n");
2165   if (class_binding_level)
2166     {
2167       for (b = class_binding_level; b; b = b->level_chain)
2168         if (b == current_binding_level)
2169           break;
2170       if (b)
2171         b = class_binding_level;
2172       else
2173         b = current_binding_level;
2174     }
2175   else
2176     b = current_binding_level;
2177   print_other_binding_stack (b);
2178   fprintf (stderr, "global:\n");
2179   print_binding_level (global_binding_level);
2180 }
2181
2182 /* Namespace binding access routines: The namespace_bindings field of
2183    the identifier is polymorphic, with three possible values:
2184    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2185    indicating the BINDING_VALUE of global_namespace. */
2186
2187 /* Check whether the a binding for the name to scope is known.
2188    Assumes that the bindings of the name are already a list
2189    of bindings. Returns the binding found, or NULL_TREE. */
2190
2191 static tree
2192 find_binding (name, scope)
2193      tree name;
2194      tree scope;
2195 {
2196   tree iter, prev = NULL_TREE;
2197
2198   scope = ORIGINAL_NAMESPACE (scope);
2199
2200   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2201        iter = TREE_CHAIN (iter))
2202     {
2203       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2204       if (BINDING_SCOPE (iter) == scope)
2205         {
2206           /* Move binding found to the front of the list, so
2207              subsequent lookups will find it faster. */
2208           if (prev)
2209             {
2210               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2211               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2212               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2213             }
2214           return iter;
2215         }
2216       prev = iter;
2217     }
2218   return NULL_TREE;
2219 }
2220
2221 /* Always returns a binding for name in scope. If the
2222    namespace_bindings is not a list, convert it to one first.
2223    If no binding is found, make a new one. */
2224
2225 tree
2226 binding_for_name (name, scope)
2227      tree name;
2228      tree scope;
2229 {
2230   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2231   tree result;
2232
2233   scope = ORIGINAL_NAMESPACE (scope);
2234
2235   if (b && TREE_CODE (b) != CPLUS_BINDING)
2236     {
2237       /* Get rid of optimization for global scope. */
2238       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2239       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2240       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2241     }
2242   if (b && (result = find_binding (name, scope)))
2243     return result;
2244   /* Not found, make a new one. */
2245   result = make_node (CPLUS_BINDING);
2246   TREE_CHAIN (result) = b;
2247   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2248   BINDING_SCOPE (result) = scope;
2249   BINDING_TYPE (result) = NULL_TREE;
2250   BINDING_VALUE (result) = NULL_TREE;
2251   return result;
2252 }
2253
2254 /* Return the binding value for name in scope, considering that
2255    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2256
2257 tree
2258 namespace_binding (name, scope)
2259      tree name;
2260      tree scope;
2261 {
2262   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2263   if (b == NULL_TREE)
2264     return NULL_TREE;
2265   if (scope == NULL_TREE)
2266     scope = global_namespace;
2267   if (TREE_CODE (b) != CPLUS_BINDING)
2268     return (scope == global_namespace) ? b : NULL_TREE;
2269   name = find_binding (name,scope);
2270   if (name == NULL_TREE)
2271     return name;
2272   return BINDING_VALUE (name);
2273 }
2274
2275 /* Set the binding value for name in scope. If modifying the binding
2276    of global_namespace is attempted, try to optimize it. */
2277
2278 void
2279 set_namespace_binding (name, scope, val)
2280      tree name;
2281      tree scope;
2282      tree val;
2283 {
2284   tree b;
2285
2286   if (scope == NULL_TREE)
2287     scope = global_namespace;
2288
2289   if (scope == global_namespace)
2290     {
2291       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2292       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2293         {
2294           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2295           return;
2296         }
2297     }
2298   b = binding_for_name (name, scope);
2299   BINDING_VALUE (b) = val;
2300 }
2301
2302 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2303    select a name that is unique to this compilation unit.  */
2304
2305 void
2306 push_namespace (name)
2307      tree name;
2308 {
2309   tree d = NULL_TREE;
2310   int need_new = 1;
2311   int implicit_use = 0;
2312   int global = 0;
2313   if (!global_namespace)
2314     {
2315       /* This must be ::. */
2316       my_friendly_assert (name == get_identifier ("::"), 377);
2317       global = 1;
2318     }
2319   else if (!name)
2320     {
2321       /* The name of anonymous namespace is unique for the translation
2322          unit.  */
2323       if (!anonymous_namespace_name)
2324         anonymous_namespace_name = get_file_function_name ('N');
2325       name = anonymous_namespace_name;
2326       d = IDENTIFIER_NAMESPACE_VALUE (name);
2327       if (d)
2328         /* Reopening anonymous namespace.  */
2329         need_new = 0;
2330       implicit_use = 1;
2331     }
2332   else if (current_namespace == global_namespace
2333            && name == DECL_NAME (std_node))
2334     {
2335       in_std++;
2336       return;
2337     }
2338   else
2339     {
2340       /* Check whether this is an extended namespace definition. */
2341       d = IDENTIFIER_NAMESPACE_VALUE (name);
2342       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2343         {
2344           need_new = 0;
2345           if (DECL_NAMESPACE_ALIAS (d))
2346             {
2347               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2348                         d, DECL_NAMESPACE_ALIAS (d));
2349               d = DECL_NAMESPACE_ALIAS (d);
2350             }
2351         }
2352     }
2353
2354   if (need_new)
2355     {
2356       /* Make a new namespace, binding the name to it. */
2357       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2358       /* The global namespace is not pushed, and the global binding
2359          level is set elsewhere.  */
2360       if (!global)
2361         {
2362           d = pushdecl (d);
2363           pushlevel (0);
2364           declare_namespace_level ();
2365           NAMESPACE_LEVEL (d) = current_binding_level;
2366         }
2367     }
2368   else
2369     resume_binding_level (NAMESPACE_LEVEL (d));
2370
2371   if (implicit_use)
2372     do_using_directive (d);
2373   /* Enter the name space. */
2374   current_namespace = d;
2375 }
2376
2377 /* Pop from the scope of the current namespace.  */
2378
2379 void
2380 pop_namespace ()
2381 {
2382   if (current_namespace == global_namespace)
2383     {
2384       my_friendly_assert (in_std>0, 980421);
2385       in_std--;
2386       return;
2387     }
2388   current_namespace = CP_DECL_CONTEXT (current_namespace);
2389   /* The binding level is not popped, as it might be re-opened later.  */
2390   suspend_binding_level ();
2391 }
2392
2393 /* Push into the scope of the namespace NS, even if it is deeply
2394    nested within another namespace.  */
2395
2396 void
2397 push_nested_namespace (ns)
2398      tree ns;
2399 {
2400   if (ns == global_namespace)
2401     push_to_top_level ();
2402   else
2403     {
2404       push_nested_namespace (CP_DECL_CONTEXT (ns));
2405       push_namespace (DECL_NAME (ns));
2406     }
2407 }
2408
2409 /* Pop back from the scope of the namespace NS, which was previously
2410    entered with push_nested_namespace.  */
2411
2412 void
2413 pop_nested_namespace (ns)
2414      tree ns;
2415 {
2416   while (ns != global_namespace)
2417     {
2418       pop_namespace ();
2419       ns = CP_DECL_CONTEXT (ns);
2420     }
2421
2422   pop_from_top_level ();
2423 }
2424
2425 \f
2426 /* Subroutines for reverting temporarily to top-level for instantiation
2427    of templates and such.  We actually need to clear out the class- and
2428    local-value slots of all identifiers, so that only the global values
2429    are at all visible.  Simply setting current_binding_level to the global
2430    scope isn't enough, because more binding levels may be pushed.  */
2431 struct saved_scope *scope_chain;
2432
2433 /* Mark ST for GC.  */
2434
2435 static void
2436 mark_stmt_tree (st)
2437      struct stmt_tree *st;
2438 {
2439   ggc_mark_tree (st->x_last_stmt);
2440   ggc_mark_tree (st->x_last_expr_type);
2441 }
2442
2443 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2444
2445 static void
2446 mark_saved_scope (arg)
2447      void *arg;
2448 {
2449   struct saved_scope *t = *(struct saved_scope **)arg;
2450   while (t)
2451     {
2452       mark_binding_level (&t->class_bindings);
2453       ggc_mark_tree (t->old_bindings);
2454       ggc_mark_tree (t->old_namespace);
2455       ggc_mark_tree (t->class_name);
2456       ggc_mark_tree (t->class_type);
2457       ggc_mark_tree (t->access_specifier);
2458       ggc_mark_tree (t->function_decl);
2459       if (t->lang_base)
2460         ggc_mark_tree_varray (t->lang_base);
2461       ggc_mark_tree (t->lang_name);
2462       ggc_mark_tree (t->x_function_parms);
2463       ggc_mark_tree (t->template_parms);
2464       ggc_mark_tree (t->x_previous_class_type);
2465       ggc_mark_tree (t->x_previous_class_values);
2466       ggc_mark_tree (t->x_saved_tree);
2467       ggc_mark_tree (t->incomplete);
2468       ggc_mark_tree (t->lookups);
2469
2470       mark_stmt_tree (&t->x_stmt_tree);
2471       mark_binding_level (&t->bindings);
2472       t = t->prev;
2473     }
2474 }
2475
2476 static tree
2477 store_bindings (names, old_bindings)
2478      tree names, old_bindings;
2479 {
2480   tree t;
2481   for (t = names; t; t = TREE_CHAIN (t))
2482     {
2483       tree binding, t1, id;
2484
2485       if (TREE_CODE (t) == TREE_LIST)
2486         id = TREE_PURPOSE (t);
2487       else
2488         id = DECL_NAME (t);
2489
2490       if (!id
2491           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2492              we have no IDENTIFIER_BINDING if we have left the class
2493              scope, but cached the class-level declarations.  */
2494           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2495         continue;
2496
2497       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2498         if (TREE_VEC_ELT (t1, 0) == id)
2499           goto skip_it;
2500
2501       binding = make_tree_vec (4);
2502
2503       if (id)
2504         {
2505           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2506           TREE_VEC_ELT (binding, 0) = id;
2507           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2508           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2509           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2510           IDENTIFIER_BINDING (id) = NULL_TREE;
2511           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2512         }
2513       TREE_CHAIN (binding) = old_bindings;
2514       old_bindings = binding;
2515     skip_it:
2516       ;
2517     }
2518   return old_bindings;
2519 }
2520
2521 void
2522 maybe_push_to_top_level (pseudo)
2523      int pseudo;
2524 {
2525   struct saved_scope *s;
2526   struct binding_level *b;
2527   tree old_bindings;
2528   int need_pop;
2529
2530   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2531
2532   b = scope_chain ? current_binding_level : 0;
2533
2534   /* If we're in the middle of some function, save our state.  */
2535   if (cfun)
2536     {
2537       need_pop = 1;
2538       push_function_context_to (NULL_TREE);
2539     }
2540   else
2541     need_pop = 0;
2542
2543   old_bindings = NULL_TREE;
2544   if (scope_chain && previous_class_type)
2545     old_bindings = store_bindings (previous_class_values, old_bindings);
2546
2547   /* Have to include global_binding_level, because class-level decls
2548      aren't listed anywhere useful.  */
2549   for (; b; b = b->level_chain)
2550     {
2551       tree t;
2552
2553       /* Template IDs are inserted into the global level. If they were
2554          inserted into namespace level, finish_file wouldn't find them
2555          when doing pending instantiations. Therefore, don't stop at
2556          namespace level, but continue until :: .  */
2557       if (b == global_binding_level || (pseudo && b->template_parms_p))
2558         break;
2559
2560       old_bindings = store_bindings (b->names, old_bindings);
2561       /* We also need to check class_shadowed to save class-level type
2562          bindings, since pushclass doesn't fill in b->names.  */
2563       if (b->parm_flag == 2)
2564         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2565
2566       /* Unwind type-value slots back to top level.  */
2567       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2568         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2569     }
2570   s->prev = scope_chain;
2571   s->old_bindings = old_bindings;
2572   s->bindings = b;
2573   s->need_pop_function_context = need_pop;
2574   s->function_decl = current_function_decl;
2575
2576   scope_chain = s;
2577   current_function_decl = NULL_TREE;
2578   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2579   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2580   current_lang_name = lang_name_cplusplus;
2581   strict_prototype = strict_prototypes_lang_cplusplus;
2582   current_namespace = global_namespace;
2583 }
2584
2585 void
2586 push_to_top_level ()
2587 {
2588   maybe_push_to_top_level (0);
2589 }
2590
2591 void
2592 pop_from_top_level ()
2593 {
2594   struct saved_scope *s = scope_chain;
2595   tree t;
2596
2597   /* Clear out class-level bindings cache.  */
2598   if (previous_class_type)
2599     invalidate_class_lookup_cache ();
2600
2601   VARRAY_FREE (current_lang_base);
2602
2603   scope_chain = s->prev;
2604   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2605     {
2606       tree id = TREE_VEC_ELT (t, 0);
2607       if (id)
2608         {
2609           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2610           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2611           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2612         }
2613     }
2614
2615   if (current_lang_name == lang_name_cplusplus)
2616     strict_prototype = strict_prototypes_lang_cplusplus;
2617   else if (current_lang_name == lang_name_c)
2618     strict_prototype = strict_prototypes_lang_c;
2619
2620   /* If we were in the middle of compiling a function, restore our
2621      state.  */
2622   if (s->need_pop_function_context)
2623     pop_function_context_from (NULL_TREE);
2624   current_function_decl = s->function_decl;
2625
2626   free (s);
2627 }
2628 \f
2629 /* Push a definition of struct, union or enum tag "name".
2630    into binding_level "b".   "type" should be the type node,
2631    We assume that the tag "name" is not already defined.
2632
2633    Note that the definition may really be just a forward reference.
2634    In that case, the TYPE_SIZE will be a NULL_TREE.
2635
2636    C++ gratuitously puts all these tags in the name space.  */
2637
2638 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2639    record the shadowed value for this binding contour.  TYPE is
2640    the type that ID maps to.  */
2641
2642 static void
2643 set_identifier_type_value_with_scope (id, type, b)
2644      tree id;
2645      tree type;
2646      struct binding_level *b;
2647 {
2648   if (!b->namespace_p)
2649     {
2650       /* Shadow the marker, not the real thing, so that the marker
2651          gets restored later. */
2652       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2653       b->type_shadowed
2654         = tree_cons (id, old_type_value, b->type_shadowed);
2655     }
2656   else
2657     {
2658       tree binding = binding_for_name (id, current_namespace);
2659       BINDING_TYPE (binding) = type;
2660       /* Store marker instead of real type. */
2661       type = global_type_node;
2662     }
2663   SET_IDENTIFIER_TYPE_VALUE (id, type);
2664 }
2665
2666 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2667
2668 void
2669 set_identifier_type_value (id, type)
2670      tree id;
2671      tree type;
2672 {
2673   set_identifier_type_value_with_scope (id, type, current_binding_level);
2674 }
2675
2676 /* Return the type associated with id. */
2677
2678 tree
2679 identifier_type_value (id)
2680      tree id;
2681 {
2682   /* There is no type with that name, anywhere. */
2683   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2684     return NULL_TREE;
2685   /* This is not the type marker, but the real thing. */
2686   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2687     return REAL_IDENTIFIER_TYPE_VALUE (id);
2688   /* Have to search for it. It must be on the global level, now.
2689      Ask lookup_name not to return non-types. */
2690   id = lookup_name_real (id, 2, 1, 0);
2691   if (id)
2692     return TREE_TYPE (id);
2693   return NULL_TREE;
2694 }
2695
2696 /* Pop off extraneous binding levels left over due to syntax errors.
2697
2698    We don't pop past namespaces, as they might be valid.  */
2699
2700 void
2701 pop_everything ()
2702 {
2703 #ifdef DEBUG_CP_BINDING_LEVELS
2704   fprintf (stderr, "XXX entering pop_everything ()\n");
2705 #endif
2706   while (!toplevel_bindings_p ())
2707     {
2708       if (current_binding_level->parm_flag == 2)
2709         pop_nested_class ();
2710       else
2711         poplevel (0, 0, 0);
2712     }
2713 #ifdef DEBUG_CP_BINDING_LEVELS
2714   fprintf (stderr, "XXX leaving pop_everything ()\n");
2715 #endif
2716 }
2717
2718 /* The type TYPE is being declared.  If it is a class template, or a
2719    specialization of a class template, do any processing required and
2720    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2721    being declared a friend.  B is the binding level at which this TYPE
2722    should be bound.
2723
2724    Returns the TYPE_DECL for TYPE, which may have been altered by this
2725    processing.  */
2726
2727 static tree
2728 maybe_process_template_type_declaration (type, globalize, b)
2729      tree type;
2730      int globalize;
2731      struct binding_level* b;
2732 {
2733   tree decl = TYPE_NAME (type);
2734
2735   if (processing_template_parmlist)
2736     /* You can't declare a new template type in a template parameter
2737        list.  But, you can declare a non-template type:
2738
2739          template <class A*> struct S;
2740
2741        is a forward-declaration of `A'.  */
2742     ;
2743   else
2744     {
2745       maybe_check_template_type (type);
2746
2747       my_friendly_assert (IS_AGGR_TYPE (type)
2748                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2749
2750
2751       if (processing_template_decl)
2752         {
2753           /* This may change after the call to
2754              push_template_decl_real, but we want the original value.  */
2755           tree name = DECL_NAME (decl);
2756
2757           decl = push_template_decl_real (decl, globalize);
2758           /* If the current binding level is the binding level for the
2759              template parameters (see the comment in
2760              begin_template_parm_list) and the enclosing level is a class
2761              scope, and we're not looking at a friend, push the
2762              declaration of the member class into the class scope.  In the
2763              friend case, push_template_decl will already have put the
2764              friend into global scope, if appropriate.  */
2765           if (TREE_CODE (type) != ENUMERAL_TYPE
2766               && !globalize && b->template_parms_p
2767               && b->level_chain->parm_flag == 2)
2768             {
2769               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2770               /* Put this tag on the list of tags for the class, since
2771                  that won't happen below because B is not the class
2772                  binding level, but is instead the pseudo-global level.  */
2773               b->level_chain->tags =
2774                 tree_cons (name, type, b->level_chain->tags);
2775               if (!COMPLETE_TYPE_P (current_class_type))
2776                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2777             }
2778         }
2779     }
2780
2781   return decl;
2782 }
2783
2784 /* In C++, you don't have to write `struct S' to refer to `S'; you
2785    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2786    if the user had written `typedef struct S S'.  Create and return
2787    the TYPE_DECL for TYPE.  */
2788
2789 tree
2790 create_implicit_typedef (name, type)
2791      tree name;
2792      tree type;
2793 {
2794   tree decl;
2795
2796   decl = build_decl (TYPE_DECL, name, type);
2797   SET_DECL_ARTIFICIAL (decl);
2798   /* There are other implicit type declarations, like the one *within*
2799      a class that allows you to write `S::S'.  We must distinguish
2800      amongst these.  */
2801   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2802   TYPE_NAME (type) = decl;
2803
2804   return decl;
2805 }
2806
2807 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2808    Normally put it into the inner-most non-tag-transparent scope,
2809    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2810    The latter is needed for implicit declarations.  */
2811
2812 void
2813 pushtag (name, type, globalize)
2814      tree name, type;
2815      int globalize;
2816 {
2817   register struct binding_level *b;
2818
2819   b = current_binding_level;
2820   while (b->tag_transparent
2821          || (globalize && b->parm_flag == 2))
2822     b = b->level_chain;
2823
2824   b->tags = tree_cons (name, type, b->tags);
2825
2826   if (name)
2827     {
2828       /* Do C++ gratuitous typedefing.  */
2829       if (IDENTIFIER_TYPE_VALUE (name) != type)
2830         {
2831           register tree d = NULL_TREE;
2832           int in_class = 0;
2833           tree context = TYPE_CONTEXT (type);
2834
2835           if (! context)
2836             {
2837               tree cs = current_scope ();
2838
2839               if (! globalize)
2840                 context = cs;
2841               else if (cs != NULL_TREE && TYPE_P (cs))
2842                 /* When declaring a friend class of a local class, we want
2843                    to inject the newly named class into the scope
2844                    containing the local class, not the namespace scope.  */
2845                 context = decl_function_context (get_type_decl (cs));
2846             }
2847           if (!context)
2848             context = current_namespace;
2849
2850           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2851               || b->parm_flag == 2)
2852             in_class = 1;
2853
2854           if (current_lang_name == lang_name_java)
2855             TYPE_FOR_JAVA (type) = 1;
2856
2857           d = create_implicit_typedef (name, type);
2858           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2859           if (! in_class)
2860             set_identifier_type_value_with_scope (name, type, b);
2861
2862           d = maybe_process_template_type_declaration (type,
2863                                                        globalize, b);
2864
2865           if (b->parm_flag == 2)
2866             {
2867               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2868                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2869                    class.  But if it's a member template class, we
2870                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2871                    is done later.  */
2872                 finish_member_declaration (d);
2873               else
2874                 pushdecl_class_level (d);
2875             }
2876           else
2877             d = pushdecl_with_scope (d, b);
2878
2879           if (ANON_AGGRNAME_P (name))
2880             DECL_IGNORED_P (d) = 1;
2881
2882           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2883           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2884
2885           /* If this is a local class, keep track of it.  We need this
2886              information for name-mangling, and so that it is possible to find
2887              all function definitions in a translation unit in a convenient
2888              way.  (It's otherwise tricky to find a member function definition
2889              it's only pointed to from within a local class.)  */
2890           if (TYPE_CONTEXT (type)
2891               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
2892             VARRAY_PUSH_TREE (local_classes, type);
2893
2894           if (!uses_template_parms (type))
2895             {
2896               if (flag_new_abi)
2897                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2898               else
2899                 DECL_ASSEMBLER_NAME (d)
2900                   = get_identifier (build_overload_name (type, 1, 1));
2901             }
2902         }
2903       if (b->parm_flag == 2)
2904         {
2905           if (!COMPLETE_TYPE_P (current_class_type))
2906             CLASSTYPE_TAGS (current_class_type) = b->tags;
2907         }
2908     }
2909
2910   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2911     /* Use the canonical TYPE_DECL for this node.  */
2912     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2913   else
2914     {
2915       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2916          will be the tagged type we just added to the current
2917          binding level.  This fake NULL-named TYPE_DECL node helps
2918          dwarfout.c to know when it needs to output a
2919          representation of a tagged type, and it also gives us a
2920          convenient place to record the "scope start" address for
2921          the tagged type.  */
2922
2923       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2924       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2925     }
2926 }
2927
2928 /* Counter used to create anonymous type names.  */
2929
2930 static int anon_cnt = 0;
2931
2932 /* Return an IDENTIFIER which can be used as a name for
2933    anonymous structs and unions.  */
2934
2935 tree
2936 make_anon_name ()
2937 {
2938   char buf[32];
2939
2940   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2941   return get_identifier (buf);
2942 }
2943
2944 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2945    This keeps dbxout from getting confused.  */
2946
2947 void
2948 clear_anon_tags ()
2949 {
2950   register struct binding_level *b;
2951   register tree tags;
2952   static int last_cnt = 0;
2953
2954   /* Fast out if no new anon names were declared.  */
2955   if (last_cnt == anon_cnt)
2956     return;
2957
2958   b = current_binding_level;
2959   while (b->tag_transparent)
2960     b = b->level_chain;
2961   tags = b->tags;
2962   while (tags)
2963     {
2964       /* A NULL purpose means we have already processed all tags
2965          from here to the end of the list.  */
2966       if (TREE_PURPOSE (tags) == NULL_TREE)
2967         break;
2968       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2969         TREE_PURPOSE (tags) = NULL_TREE;
2970       tags = TREE_CHAIN (tags);
2971     }
2972   last_cnt = anon_cnt;
2973 }
2974 \f
2975 /* Subroutine of duplicate_decls: return truthvalue of whether
2976    or not types of these decls match.
2977
2978    For C++, we must compare the parameter list so that `int' can match
2979    `int&' in a parameter position, but `int&' is not confused with
2980    `const int&'.  */
2981
2982 int
2983 decls_match (newdecl, olddecl)
2984      tree newdecl, olddecl;
2985 {
2986   int types_match;
2987
2988   if (newdecl == olddecl)
2989     return 1;
2990
2991   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2992     /* If the two DECLs are not even the same kind of thing, we're not
2993        interested in their types.  */
2994     return 0;
2995
2996   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2997     {
2998       tree f1 = TREE_TYPE (newdecl);
2999       tree f2 = TREE_TYPE (olddecl);
3000       tree p1 = TYPE_ARG_TYPES (f1);
3001       tree p2 = TYPE_ARG_TYPES (f2);
3002
3003       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3004           && ! (DECL_EXTERN_C_P (newdecl)
3005                 && DECL_EXTERN_C_P (olddecl)))
3006         return 0;
3007
3008       if (TREE_CODE (f1) != TREE_CODE (f2))
3009         return 0;
3010
3011       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3012         {
3013           if ((! strict_prototypes_lang_c || DECL_BUILT_IN (olddecl))
3014               && DECL_EXTERN_C_P (olddecl)
3015               && p2 == NULL_TREE)
3016             {
3017               types_match = self_promoting_args_p (p1);
3018               if (p1 == void_list_node)
3019                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3020             }
3021           else if (!strict_prototypes_lang_c
3022                    && DECL_EXTERN_C_P (olddecl)
3023                    && DECL_EXTERN_C_P (newdecl)
3024                    && p1 == NULL_TREE)
3025             {
3026               types_match = self_promoting_args_p (p2);
3027               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3028             }
3029           else
3030             types_match = compparms (p1, p2);
3031         }
3032       else
3033         types_match = 0;
3034     }
3035   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3036     {
3037       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3038                                 DECL_TEMPLATE_PARMS (olddecl)))
3039         return 0;
3040
3041       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3042         types_match = 1;
3043       else
3044         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3045                                    DECL_TEMPLATE_RESULT (newdecl));
3046     }
3047   else
3048     {
3049       if (TREE_TYPE (newdecl) == error_mark_node)
3050         types_match = TREE_TYPE (olddecl) == error_mark_node;
3051       else if (TREE_TYPE (olddecl) == NULL_TREE)
3052         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3053       else if (TREE_TYPE (newdecl) == NULL_TREE)
3054         types_match = 0;
3055       else
3056         types_match = comptypes (TREE_TYPE (newdecl),
3057                                  TREE_TYPE (olddecl),
3058                                  COMPARE_REDECLARATION);
3059     }
3060
3061   return types_match;
3062 }
3063
3064 /* If NEWDECL is `static' and an `extern' was seen previously,
3065    warn about it.  OLDDECL is the previous declaration.
3066
3067    Note that this does not apply to the C++ case of declaring
3068    a variable `extern const' and then later `const'.
3069
3070    Don't complain about built-in functions, since they are beyond
3071    the user's control.  */
3072
3073 static void
3074 warn_extern_redeclared_static (newdecl, olddecl)
3075      tree newdecl, olddecl;
3076 {
3077   static const char *explicit_extern_static_warning
3078     = "`%D' was declared `extern' and later `static'";
3079   static const char *implicit_extern_static_warning
3080     = "`%D' was declared implicitly `extern' and later `static'";
3081
3082   tree name;
3083
3084   if (TREE_CODE (newdecl) == TYPE_DECL
3085       || TREE_CODE (newdecl) == TEMPLATE_DECL)
3086     return;
3087
3088   /* Don't get confused by static member functions; that's a different
3089      use of `static'.  */
3090   if (TREE_CODE (newdecl) == FUNCTION_DECL
3091       && DECL_STATIC_FUNCTION_P (newdecl))
3092     return;
3093
3094   /* If the old declaration was `static', or the new one isn't, then
3095      then everything is OK.  */
3096   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3097     return;
3098
3099   /* It's OK to declare a builtin function as `static'.  */
3100   if (TREE_CODE (olddecl) == FUNCTION_DECL
3101       && DECL_ARTIFICIAL (olddecl))
3102     return;
3103
3104   name = DECL_ASSEMBLER_NAME (newdecl);
3105   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3106               ? implicit_extern_static_warning
3107               : explicit_extern_static_warning, newdecl);
3108   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3109 }
3110
3111 /* Handle when a new declaration NEWDECL has the same name as an old
3112    one OLDDECL in the same binding contour.  Prints an error message
3113    if appropriate.
3114
3115    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3116    Otherwise, return 0.  */
3117
3118 int
3119 duplicate_decls (newdecl, olddecl)
3120      tree newdecl, olddecl;
3121 {
3122   unsigned olddecl_uid = DECL_UID (olddecl);
3123   int olddecl_friend = 0, types_match = 0;
3124   int new_defines_function = 0;
3125
3126   if (newdecl == olddecl)
3127     return 1;
3128
3129   types_match = decls_match (newdecl, olddecl);
3130
3131   /* If either the type of the new decl or the type of the old decl is an
3132      error_mark_node, then that implies that we have already issued an
3133      error (earlier) for some bogus type specification, and in that case,
3134      it is rather pointless to harass the user with yet more error message
3135      about the same declaration, so just pretend the types match here.  */
3136   if (TREE_TYPE (newdecl) == error_mark_node
3137       || TREE_TYPE (olddecl) == error_mark_node)
3138     types_match = 1;
3139
3140   /* Check for redeclaration and other discrepancies. */
3141   if (TREE_CODE (olddecl) == FUNCTION_DECL
3142       && DECL_ARTIFICIAL (olddecl))
3143     {
3144       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3145         {
3146           /* If you declare a built-in or predefined function name as static,
3147              the old definition is overridden, but optionally warn this was a
3148              bad choice of name.  */
3149           if (! TREE_PUBLIC (newdecl))
3150             {
3151               if (warn_shadow)
3152                 cp_warning ("shadowing %s function `%#D'",
3153                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3154                             olddecl);
3155               /* Discard the old built-in function.  */
3156               return 0;
3157             }
3158           /* If the built-in is not ansi, then programs can override
3159              it even globally without an error.  */
3160           else if (! DECL_BUILT_IN (olddecl))
3161             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3162                         olddecl, newdecl);
3163           else
3164             {
3165               cp_error ("declaration of `%#D'", newdecl);
3166               cp_error ("conflicts with built-in declaration `%#D'",
3167                         olddecl);
3168             }
3169           return 0;
3170         }
3171       else if (!types_match)
3172         {
3173           if ((DECL_EXTERN_C_P (newdecl)
3174                && DECL_EXTERN_C_P (olddecl))
3175               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3176                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3177             {
3178               /* A near match; override the builtin.  */
3179
3180               if (TREE_PUBLIC (newdecl))
3181                 {
3182                   cp_warning ("new declaration `%#D'", newdecl);
3183                   cp_warning ("ambiguates built-in declaration `%#D'",
3184                               olddecl);
3185                 }
3186               else if (warn_shadow)
3187                 cp_warning ("shadowing %s function `%#D'",
3188                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3189                             olddecl);
3190             }
3191           else
3192             /* Discard the old built-in function.  */
3193             return 0;
3194         }
3195
3196       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3197         {
3198           /* If a builtin function is redeclared as `static', merge
3199              the declarations, but make the original one static.  */
3200           DECL_THIS_STATIC (olddecl) = 1;
3201           TREE_PUBLIC (olddecl) = 0;
3202
3203           /* Make the old declaration consistent with the new one so
3204              that all remnants of the builtin-ness of this function
3205              will be banished.  */
3206           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3207           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3208           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3209           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3210                                        newdecl);
3211         }
3212     }
3213   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3214     {
3215       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3216            && TREE_CODE (newdecl) != TYPE_DECL
3217            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3218                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3219           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3220               && TREE_CODE (olddecl) != TYPE_DECL
3221               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3222                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3223                         == TYPE_DECL))))
3224         {
3225           /* We do nothing special here, because C++ does such nasty
3226              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3227              get shadowed, and know that if we need to find a TYPE_DECL
3228              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3229              slot of the identifier.  */
3230           return 0;
3231         }
3232
3233       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3234            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3235           || (TREE_CODE (olddecl) == FUNCTION_DECL
3236               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3237         return 0;
3238
3239       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3240       if (TREE_CODE (olddecl) == TREE_LIST)
3241         olddecl = TREE_VALUE (olddecl);
3242       cp_error_at ("previous declaration of `%#D'", olddecl);
3243
3244       /* New decl is completely inconsistent with the old one =>
3245          tell caller to replace the old one.  */
3246
3247       return 0;
3248     }
3249   else if (!types_match)
3250     {
3251       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3252         /* These are certainly not duplicate declarations; they're
3253            from different scopes.  */
3254         return 0;
3255
3256       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3257         {
3258           /* The name of a class template may not be declared to refer to
3259              any other template, class, function, object, namespace, value,
3260              or type in the same scope.  */
3261           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3262               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3263             {
3264               cp_error ("declaration of template `%#D'", newdecl);
3265               cp_error_at ("conflicts with previous declaration `%#D'",
3266                            olddecl);
3267             }
3268           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3269                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3270                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3271                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3272                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3273                                            DECL_TEMPLATE_PARMS (olddecl)))
3274             {
3275               cp_error ("new declaration `%#D'", newdecl);
3276               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3277             }
3278           return 0;
3279         }
3280       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3281         {
3282           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3283             {
3284               cp_error ("declaration of C function `%#D' conflicts with",
3285                         newdecl);
3286               cp_error_at ("previous declaration `%#D' here", olddecl);
3287             }
3288           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3289                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3290             {
3291               cp_error ("new declaration `%#D'", newdecl);
3292               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3293             }
3294           else
3295             return 0;
3296         }
3297
3298       /* Already complained about this, so don't do so again.  */
3299       else if (current_class_type == NULL_TREE
3300           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3301         {
3302           cp_error ("conflicting types for `%#D'", newdecl);
3303           cp_error_at ("previous declaration as `%#D'", olddecl);
3304         }
3305     }
3306   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3307             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3308                  && (!DECL_TEMPLATE_INFO (newdecl)
3309                      || (DECL_TI_TEMPLATE (newdecl)
3310                          != DECL_TI_TEMPLATE (olddecl))))
3311                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3312                     && (!DECL_TEMPLATE_INFO (olddecl)
3313                         || (DECL_TI_TEMPLATE (olddecl)
3314                             != DECL_TI_TEMPLATE (newdecl))))))
3315     /* It's OK to have a template specialization and a non-template
3316        with the same type, or to have specializations of two
3317        different templates with the same type.  Note that if one is a
3318        specialization, and the other is an instantiation of the same
3319        template, that we do not exit at this point.  That situation
3320        can occur if we instantiate a template class, and then
3321        specialize one of its methods.  This situation is legal, but
3322        the declarations must be merged in the usual way.  */
3323     return 0;
3324   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3325            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3326                 && !DECL_USE_TEMPLATE (newdecl))
3327                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3328                    && !DECL_USE_TEMPLATE (olddecl))))
3329     /* One of the declarations is a template instantiation, and the
3330        other is not a template at all.  That's OK.  */
3331     return 0;
3332   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3333            && DECL_NAMESPACE_ALIAS (newdecl)
3334            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3335     /* Redeclaration of namespace alias, ignore it. */
3336     return 1;
3337   else
3338     {
3339       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3340       if (errmsg)
3341         {
3342           cp_error (errmsg, newdecl);
3343           if (DECL_NAME (olddecl) != NULL_TREE)
3344             cp_error_at ((DECL_INITIAL (olddecl)
3345                           && namespace_bindings_p ())
3346                          ? "`%#D' previously defined here"
3347                          : "`%#D' previously declared here", olddecl);
3348         }
3349       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3350                && DECL_INITIAL (olddecl) != NULL_TREE
3351                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3352                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3353         {
3354           /* Prototype decl follows defn w/o prototype.  */
3355           cp_warning_at ("prototype for `%#D'", newdecl);
3356           cp_warning_at ("follows non-prototype definition here", olddecl);
3357         }
3358       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3359                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3360         {
3361           /* extern "C" int foo ();
3362              int foo () { bar (); }
3363              is OK.  */
3364           if (current_lang_stack
3365               == &VARRAY_TREE (current_lang_base, 0))
3366             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3367           else
3368             {
3369               cp_error_at ("previous declaration of `%#D' with %L linkage",
3370                            olddecl, DECL_LANGUAGE (olddecl));
3371               cp_error ("conflicts with new declaration with %L linkage",
3372                         DECL_LANGUAGE (newdecl));
3373             }
3374         }
3375
3376       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3377         ;
3378       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3379         {
3380           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3381           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3382           int i = 1;
3383
3384           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3385             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3386
3387           for (; t1 && t1 != void_list_node;
3388                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3389             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3390               {
3391                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3392                                            TREE_PURPOSE (t2)))
3393                   {
3394                     if (pedantic)
3395                       {
3396                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3397                                     i, newdecl);
3398                         cp_pedwarn_at ("after previous specification in `%#D'",
3399                                        olddecl);
3400                       }
3401                   }
3402                 else
3403                   {
3404                     cp_error ("default argument given for parameter %d of `%#D'",
3405                               i, newdecl);
3406                     cp_error_at ("after previous specification in `%#D'",
3407                                  olddecl);
3408                   }
3409               }
3410
3411           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3412               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3413             {
3414               cp_warning ("`%#D' was used before it was declared inline",
3415                           newdecl);
3416               cp_warning_at ("previous non-inline declaration here",
3417                              olddecl);
3418             }
3419         }
3420     }
3421
3422   /* If new decl is `static' and an `extern' was seen previously,
3423      warn about it.  */
3424   warn_extern_redeclared_static (newdecl, olddecl);
3425
3426   /* We have committed to returning 1 at this point.  */
3427   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3428     {
3429       /* Now that functions must hold information normally held
3430          by field decls, there is extra work to do so that
3431          declaration information does not get destroyed during
3432          definition.  */
3433       if (DECL_VINDEX (olddecl))
3434         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3435       if (DECL_VIRTUAL_CONTEXT (olddecl))
3436         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3437       if (DECL_CONTEXT (olddecl))
3438         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3439       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3440         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3441       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3442       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3443       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3444       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3445       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3446       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3447       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3448       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3449
3450       /* Optionally warn about more than one declaration for the same
3451          name, but don't warn about a function declaration followed by a
3452          definition.  */
3453       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3454           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3455           /* Don't warn about extern decl followed by definition. */
3456           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3457           /* Don't warn about friends, let add_friend take care of it. */
3458           && ! DECL_FRIEND_P (newdecl))
3459         {
3460           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3461           cp_warning_at ("previous declaration of `%D'", olddecl);
3462         }
3463     }
3464
3465   /* Deal with C++: must preserve virtual function table size.  */
3466   if (TREE_CODE (olddecl) == TYPE_DECL)
3467     {
3468       register tree newtype = TREE_TYPE (newdecl);
3469       register tree oldtype = TREE_TYPE (olddecl);
3470
3471       if (newtype != error_mark_node && oldtype != error_mark_node
3472           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3473         {
3474           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3475           CLASSTYPE_FRIEND_CLASSES (newtype)
3476             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3477         }
3478     }
3479
3480   /* Copy all the DECL_... slots specified in the new decl
3481      except for any that we copy here from the old type.  */
3482   DECL_MACHINE_ATTRIBUTES (newdecl)
3483     = merge_machine_decl_attributes (olddecl, newdecl);
3484
3485   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3486     {
3487       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3488                              DECL_TEMPLATE_RESULT (olddecl)))
3489         cp_error ("invalid redeclaration of %D", newdecl);
3490       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3491       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3492         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3493                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3494
3495       return 1;
3496     }
3497
3498   if (types_match)
3499     {
3500       /* Automatically handles default parameters.  */
3501       tree oldtype = TREE_TYPE (olddecl);
3502       tree newtype;
3503
3504       /* Merge the data types specified in the two decls.  */
3505       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3506
3507       if (TREE_CODE (newdecl) == VAR_DECL)
3508         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3509       /* Do this after calling `common_type' so that default
3510          parameters don't confuse us.  */
3511       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3512           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3513               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3514         {
3515           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3516                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3517           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3518                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3519
3520           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3521               && DECL_SOURCE_LINE (olddecl) != 0
3522               && flag_exceptions
3523               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3524                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3525             {
3526               cp_error ("declaration of `%F' throws different exceptions",
3527                         newdecl);
3528               cp_error_at ("than previous declaration `%F'", olddecl);
3529             }
3530         }
3531       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3532
3533       /* Lay the type out, unless already done.  */
3534       if (! same_type_p (newtype, oldtype)
3535           && TREE_TYPE (newdecl) != error_mark_node
3536           && !(processing_template_decl && uses_template_parms (newdecl)))
3537         layout_type (TREE_TYPE (newdecl));
3538
3539       if ((TREE_CODE (newdecl) == VAR_DECL
3540            || TREE_CODE (newdecl) == PARM_DECL
3541            || TREE_CODE (newdecl) == RESULT_DECL
3542            || TREE_CODE (newdecl) == FIELD_DECL
3543            || TREE_CODE (newdecl) == TYPE_DECL)
3544           && !(processing_template_decl && uses_template_parms (newdecl)))
3545         layout_decl (newdecl, 0);
3546
3547       /* Merge the type qualifiers.  */
3548       if (TREE_READONLY (newdecl))
3549         TREE_READONLY (olddecl) = 1;
3550       if (TREE_THIS_VOLATILE (newdecl))
3551         TREE_THIS_VOLATILE (olddecl) = 1;
3552
3553       /* Merge the initialization information.  */
3554       if (DECL_INITIAL (newdecl) == NULL_TREE
3555           && DECL_INITIAL (olddecl) != NULL_TREE)
3556         {
3557           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3558           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3559           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3560           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3561               && DECL_LANG_SPECIFIC (newdecl)
3562               && DECL_LANG_SPECIFIC (olddecl))
3563             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3564         }
3565
3566       /* Merge the section attribute.
3567          We want to issue an error if the sections conflict but that must be
3568          done later in decl_attributes since we are called before attributes
3569          are assigned.  */
3570       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3571         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3572
3573       /* Keep the old rtl since we can safely use it.  */
3574       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3575
3576       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3577         {
3578           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3579             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3580           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3581             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3582           DECL_NO_LIMIT_STACK (newdecl)
3583             |= DECL_NO_LIMIT_STACK (olddecl);
3584         }
3585     }
3586   /* If cannot merge, then use the new type and qualifiers,
3587      and don't preserve the old rtl.  */
3588   else
3589     {
3590       /* Clean out any memory we had of the old declaration.  */
3591       tree oldstatic = value_member (olddecl, static_aggregates);
3592       if (oldstatic)
3593         TREE_VALUE (oldstatic) = error_mark_node;
3594
3595       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3596       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3597       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3598       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3599     }
3600
3601   /* Merge the storage class information.  */
3602   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3603   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3604   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3605   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3606   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3607   if (! DECL_EXTERNAL (olddecl))
3608     DECL_EXTERNAL (newdecl) = 0;
3609
3610   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3611     {
3612       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3613       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3614       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3615       DECL_TEMPLATE_INSTANTIATED (newdecl)
3616         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3617       /* Don't really know how much of the language-specific
3618          values we should copy from old to new.  */
3619       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3620       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3621       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3622       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3623       olddecl_friend = DECL_FRIEND_P (olddecl);
3624
3625       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3626       if (TREE_CODE (newdecl) == FUNCTION_DECL
3627           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3628         DECL_BEFRIENDING_CLASSES (newdecl)
3629           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3630                      DECL_BEFRIENDING_CLASSES (olddecl));
3631     }
3632
3633   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3634     {
3635       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3636           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3637         {
3638           /* If newdecl is not a specialization, then it is not a
3639              template-related function at all.  And that means that we
3640              shoud have exited above, returning 0.  */
3641           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3642                               0);
3643
3644           if (TREE_USED (olddecl))
3645             /* From [temp.expl.spec]:
3646
3647                If a template, a member template or the member of a class
3648                template is explicitly specialized then that
3649                specialization shall be declared before the first use of
3650                that specialization that would cause an implicit
3651                instantiation to take place, in every translation unit in
3652                which such a use occurs.  */
3653             cp_error ("explicit specialization of %D after first use",
3654                       olddecl);
3655
3656           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3657         }
3658       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3659
3660       /* If either decl says `inline', this fn is inline, unless its
3661          definition was passed already.  */
3662       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3663         DECL_INLINE (olddecl) = 1;
3664       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3665
3666       if (! types_match)
3667         {
3668           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3669           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3670           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3671         }
3672       if (! types_match || new_defines_function)
3673         {
3674           /* These need to be copied so that the names are available.
3675              Note that if the types do match, we'll preserve inline
3676              info and other bits, but if not, we won't.  */
3677           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3678           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3679         }
3680       if (new_defines_function)
3681         /* If defining a function declared with other language
3682            linkage, use the previously declared language linkage.  */
3683         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3684       else if (types_match)
3685         {
3686           /* If redeclaring a builtin function, and not a definition,
3687              it stays built in.  */
3688           if (DECL_BUILT_IN (olddecl))
3689             {
3690               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3691               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3692               /* If we're keeping the built-in definition, keep the rtl,
3693                  regardless of declaration matches.  */
3694               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3695             }
3696           else
3697             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3698
3699           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3700           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3701             /* Previously saved insns go together with
3702                the function's previous definition.  */
3703             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3704           /* Don't clear out the arguments if we're redefining a function.  */
3705           if (DECL_ARGUMENTS (olddecl))
3706             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3707         }
3708     }
3709
3710   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3711     {
3712       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3713     }
3714
3715   /* Now preserve various other info from the definition.  */
3716   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3717   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3718   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3719   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3720
3721   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3722     {
3723       int function_size;
3724
3725       function_size = sizeof (struct tree_decl);
3726
3727       bcopy ((char *) newdecl + sizeof (struct tree_common),
3728              (char *) olddecl + sizeof (struct tree_common),
3729              function_size - sizeof (struct tree_common));
3730
3731       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3732         {
3733           /* If newdecl is a template instantiation, it is possible that
3734              the following sequence of events has occurred:
3735
3736              o A friend function was declared in a class template.  The
3737              class template was instantiated.
3738
3739              o The instantiation of the friend declaration was
3740              recorded on the instantiation list, and is newdecl.
3741
3742              o Later, however, instantiate_class_template called pushdecl
3743              on the newdecl to perform name injection.  But, pushdecl in
3744              turn called duplicate_decls when it discovered that another
3745              declaration of a global function with the same name already
3746              existed.
3747
3748              o Here, in duplicate_decls, we decided to clobber newdecl.
3749
3750              If we're going to do that, we'd better make sure that
3751              olddecl, and not newdecl, is on the list of
3752              instantiations so that if we try to do the instantiation
3753              again we won't get the clobbered declaration.  */
3754
3755           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3756           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3757
3758           for (; decls; decls = TREE_CHAIN (decls))
3759             if (TREE_VALUE (decls) == newdecl)
3760               TREE_VALUE (decls) = olddecl;
3761         }
3762     }
3763   else
3764     {
3765       bcopy ((char *) newdecl + sizeof (struct tree_common),
3766              (char *) olddecl + sizeof (struct tree_common),
3767              sizeof (struct tree_decl) - sizeof (struct tree_common)
3768              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3769     }
3770
3771   DECL_UID (olddecl) = olddecl_uid;
3772   if (olddecl_friend)
3773     DECL_FRIEND_P (olddecl) = 1;
3774
3775   /* NEWDECL contains the merged attribute lists.
3776      Update OLDDECL to be the same.  */
3777   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3778
3779   return 1;
3780 }
3781
3782 /* Record a decl-node X as belonging to the current lexical scope.
3783    Check for errors (such as an incompatible declaration for the same
3784    name already seen in the same scope).
3785
3786    Returns either X or an old decl for the same name.
3787    If an old decl is returned, it may have been smashed
3788    to agree with what X says.  */
3789
3790 tree
3791 pushdecl (x)
3792      tree x;
3793 {
3794   register tree t;
3795   register tree name;
3796   int need_new_binding;
3797
3798   /* We shouldn't be calling pushdecl when we're generating RTL for a
3799      function that we already did semantic analysis on previously.  */
3800   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3801                       19990913);
3802
3803   name = DECL_ASSEMBLER_NAME (x);
3804   need_new_binding = 1;
3805
3806   if (DECL_TEMPLATE_PARM_P (x))
3807     /* Template parameters have no context; they are not X::T even
3808        when declared within a class or namespace.  */
3809     ;
3810   else
3811     {
3812       if (current_function_decl && x != current_function_decl
3813           /* A local declaration for a function doesn't constitute
3814              nesting.  */
3815           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3816           /* A local declaration for an `extern' variable is in the
3817              scoped of the current namespace, not the current
3818              function.  */
3819           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3820           && !DECL_CONTEXT (x))
3821         DECL_CONTEXT (x) = current_function_decl;
3822       if (!DECL_CONTEXT (x))
3823         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3824
3825       /* If this is the declaration for a namespace-scope function,
3826          but the declaration itself is in a local scope, mark the
3827          declaration.  */
3828       if (TREE_CODE (x) == FUNCTION_DECL
3829           && DECL_NAMESPACE_SCOPE_P (x)
3830           && current_function_decl
3831           && x != current_function_decl)
3832         DECL_LOCAL_FUNCTION_P (x) = 1;
3833     }
3834
3835   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3836      compiler wants to use.  */
3837   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3838       || TREE_CODE (x) == NAMESPACE_DECL)
3839     name = DECL_NAME (x);
3840
3841   if (name)
3842     {
3843 #if 0
3844       /* Not needed...see below.  */
3845       char *file;
3846       int line;
3847 #endif
3848       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3849         name = TREE_OPERAND (name, 0);
3850
3851       /* Namespace-scoped variables are not found in the current level. */
3852       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3853         t = namespace_binding (name, DECL_CONTEXT (x));
3854       else
3855         t = lookup_name_current_level (name);
3856       if (t == error_mark_node)
3857         {
3858           /* error_mark_node is 0 for a while during initialization!  */
3859           t = NULL_TREE;
3860           cp_error_at ("`%#D' used prior to declaration", x);
3861         }
3862
3863       else if (t != NULL_TREE)
3864         {
3865 #if 0
3866           /* This is turned off until I have time to do it right (bpk).  */
3867           /* With the code below that uses it...  */
3868           file = DECL_SOURCE_FILE (t);
3869           line = DECL_SOURCE_LINE (t);
3870 #endif
3871           if (TREE_CODE (t) == PARM_DECL)
3872             {
3873               if (DECL_CONTEXT (t) == NULL_TREE)
3874                 fatal ("parse errors have confused me too much");
3875
3876               /* Check for duplicate params.  */
3877               if (duplicate_decls (x, t))
3878                 return t;
3879             }
3880           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3881                     || DECL_FUNCTION_TEMPLATE_P (x))
3882                    && is_overloaded_fn (t))
3883             /* Don't do anything just yet. */;
3884           else if (t == wchar_decl_node)
3885             {
3886               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3887                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3888
3889               /* Throw away the redeclaration.  */
3890               return t;
3891             }
3892           else if (TREE_CODE (t) != TREE_CODE (x))
3893             {
3894               if (duplicate_decls (x, t))
3895                 return t;
3896             }
3897           else if (duplicate_decls (x, t))
3898             {
3899 #if 0
3900               /* This is turned off until I have time to do it right (bpk).  */
3901
3902               /* Also warn if they did a prototype with `static' on it, but
3903                  then later left the `static' off.  */
3904               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3905                 {
3906                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3907                     return t;
3908
3909                   if (extra_warnings)
3910                     {
3911                       cp_warning ("`static' missing from declaration of `%D'",
3912                                   t);
3913                       warning_with_file_and_line (file, line,
3914                                                   "previous declaration of `%s'",
3915                                                   decl_as_string (t, 0));
3916                     }
3917
3918                   /* Now fix things so it'll do what they expect.  */
3919                   if (current_function_decl)
3920                     TREE_PUBLIC (current_function_decl) = 0;
3921                 }
3922               /* Due to interference in memory reclamation (X may be
3923                  obstack-deallocated at this point), we must guard against
3924                  one really special case.  [jason: This should be handled
3925                  by start_function]  */
3926               if (current_function_decl == x)
3927                 current_function_decl = t;
3928 #endif
3929               if (TREE_CODE (t) == TYPE_DECL)
3930                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3931               else if (TREE_CODE (t) == FUNCTION_DECL)
3932                 check_default_args (t);
3933
3934               return t;
3935             }
3936           else if (DECL_MAIN_P (x))
3937             {
3938               /* A redeclaration of main, but not a duplicate of the
3939                  previous one.
3940
3941                  [basic.start.main]
3942
3943                  This function shall not be overloaded.  */
3944               cp_error_at ("invalid redeclaration of `%D'", t);
3945               cp_error ("as `%D'", x);
3946               /* We don't try to push this declaration since that
3947                  causes a crash.  */
3948               return x;
3949             }
3950         }
3951
3952       check_template_shadow (x);
3953
3954       /* If this is a function conjured up by the backend, massage it
3955          so it looks friendly.  */
3956       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3957         {
3958           retrofit_lang_decl (x);
3959           DECL_LANGUAGE (x) = lang_c;
3960         }
3961
3962       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3963         {
3964           t = push_overloaded_decl (x, PUSH_LOCAL);
3965           if (t != x)
3966             return t;
3967           if (!namespace_bindings_p ())
3968             /* We do not need to create a binding for this name;
3969                push_overloaded_decl will have already done so if
3970                necessary.  */
3971             need_new_binding = 0;
3972         }
3973       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3974         {
3975           t = push_overloaded_decl (x, PUSH_GLOBAL);
3976           if (t == x)
3977             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3978           return t;
3979         }
3980
3981       /* If declaring a type as a typedef, copy the type (unless we're
3982          at line 0), and install this TYPE_DECL as the new type's typedef
3983          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3984       if (TREE_CODE (x) == TYPE_DECL)
3985         {
3986           tree type = TREE_TYPE (x);
3987           if (DECL_SOURCE_LINE (x) == 0)
3988             {
3989               if (TYPE_NAME (type) == 0)
3990                 TYPE_NAME (type) = x;
3991             }
3992           else if (type != error_mark_node && TYPE_NAME (type) != x
3993                    /* We don't want to copy the type when all we're
3994                       doing is making a TYPE_DECL for the purposes of
3995                       inlining.  */
3996                    && (!TYPE_NAME (type)
3997                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3998             {
3999               DECL_ORIGINAL_TYPE (x) = type;
4000               type = build_type_copy (type);
4001               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4002               TYPE_NAME (type) = x;
4003               TREE_TYPE (x) = type;
4004             }
4005
4006           if (type != error_mark_node
4007               && TYPE_NAME (type)
4008               && TYPE_IDENTIFIER (type))
4009             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4010                                                   current_binding_level);
4011
4012         }
4013
4014       /* Multiple external decls of the same identifier ought to match.
4015
4016          We get warnings about inline functions where they are defined.
4017          We get warnings about other functions from push_overloaded_decl.
4018
4019          Avoid duplicate warnings where they are used.  */
4020       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4021         {
4022           tree decl;
4023
4024           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
4025               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
4026                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
4027             decl = IDENTIFIER_NAMESPACE_VALUE (name);
4028           else
4029             decl = NULL_TREE;
4030
4031           if (decl
4032               /* If different sort of thing, we already gave an error.  */
4033               && TREE_CODE (decl) == TREE_CODE (x)
4034               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4035             {
4036               cp_pedwarn ("type mismatch with previous external decl", x);
4037               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4038             }
4039         }
4040
4041       /* This name is new in its binding level.
4042          Install the new declaration and return it.  */
4043       if (namespace_bindings_p ())
4044         {
4045           /* Install a global value.  */
4046
4047           /* If the first global decl has external linkage,
4048              warn if we later see static one.  */
4049           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4050             TREE_PUBLIC (name) = 1;
4051
4052           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4053                 && t != NULL_TREE)
4054               /* For an ordinary function, we create a binding from
4055                  the mangled name (i.e., NAME) to the DECL.  But, for
4056                  an `extern "C"' function, the mangled name and the
4057                  ordinary name are the same so we need not do this.  */
4058               && !DECL_EXTERN_C_FUNCTION_P (x))
4059             {
4060               if (TREE_CODE (x) == FUNCTION_DECL)
4061                 my_friendly_assert
4062                   ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
4063                   || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
4064               SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4065             }
4066
4067           /* Don't forget if the function was used via an implicit decl.  */
4068           if (IDENTIFIER_IMPLICIT_DECL (name)
4069               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4070             TREE_USED (x) = 1;
4071
4072           /* Don't forget if its address was taken in that way.  */
4073           if (IDENTIFIER_IMPLICIT_DECL (name)
4074               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4075             TREE_ADDRESSABLE (x) = 1;
4076
4077           /* Warn about mismatches against previous implicit decl.  */
4078           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4079               /* If this real decl matches the implicit, don't complain.  */
4080               && ! (TREE_CODE (x) == FUNCTION_DECL
4081                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4082             cp_warning
4083               ("`%D' was previously implicitly declared to return `int'", x);
4084
4085           /* If new decl is `static' and an `extern' was seen previously,
4086              warn about it.  */
4087           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4088             warn_extern_redeclared_static (x, t);
4089         }
4090       else
4091         {
4092           /* Here to install a non-global value.  */
4093           tree oldlocal = IDENTIFIER_VALUE (name);
4094           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4095
4096           if (need_new_binding)
4097             {
4098               push_local_binding (name, x, 0);
4099               /* Because push_local_binding will hook X on to the
4100                  current_binding_level's name list, we don't want to
4101                  do that again below.  */
4102               need_new_binding = 0;
4103             }
4104
4105           /* If this is a TYPE_DECL, push it into the type value slot.  */
4106           if (TREE_CODE (x) == TYPE_DECL)
4107             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4108                                                   current_binding_level);
4109
4110           /* Clear out any TYPE_DECL shadowed by a namespace so that
4111              we won't think this is a type.  The C struct hack doesn't
4112              go through namespaces.  */
4113           if (TREE_CODE (x) == NAMESPACE_DECL)
4114             set_identifier_type_value_with_scope (name, NULL_TREE,
4115                                                   current_binding_level);
4116
4117           if (oldlocal)
4118             {
4119               tree d = oldlocal;
4120
4121               while (oldlocal
4122                      && TREE_CODE (oldlocal) == VAR_DECL
4123                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4124                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4125
4126               if (oldlocal == NULL_TREE)
4127                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4128             }
4129
4130           /* If this is an extern function declaration, see if we
4131              have a global definition or declaration for the function.  */
4132           if (oldlocal == NULL_TREE
4133               && DECL_EXTERNAL (x)
4134               && oldglobal != NULL_TREE
4135               && TREE_CODE (x) == FUNCTION_DECL
4136               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4137             {
4138               /* We have one.  Their types must agree.  */
4139               if (decls_match (x, oldglobal))
4140                 /* OK */;
4141               else
4142                 {
4143                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4144                   cp_warning_at ("global declaration `%#D'", oldglobal);
4145                 }
4146             }
4147           /* If we have a local external declaration,
4148              and no file-scope declaration has yet been seen,
4149              then if we later have a file-scope decl it must not be static.  */
4150           if (oldlocal == NULL_TREE
4151               && oldglobal == NULL_TREE
4152               && DECL_EXTERNAL (x)
4153               && TREE_PUBLIC (x))
4154             TREE_PUBLIC (name) = 1;
4155
4156           /* Warn if shadowing an argument at the top level of the body.  */
4157           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4158               /* Inline decls shadow nothing.  */
4159               && !DECL_FROM_INLINE (x)
4160               && TREE_CODE (oldlocal) == PARM_DECL
4161               /* Don't complain if it's from an enclosing function.  */
4162               && DECL_CONTEXT (oldlocal) == current_function_decl
4163               && TREE_CODE (x) != PARM_DECL)
4164             {
4165               /* Go to where the parms should be and see if we
4166                  find them there.  */
4167               struct binding_level *b = current_binding_level->level_chain;
4168
4169               if (cleanup_label)
4170                 b = b->level_chain;
4171
4172               /* ARM $8.3 */
4173               if (b->parm_flag == 1)
4174                 cp_error ("declaration of `%#D' shadows a parameter", name);
4175             }
4176
4177           /* Maybe warn if shadowing something else.  */
4178           if (warn_shadow && !DECL_EXTERNAL (x)
4179               /* Inline decls shadow nothing.  */
4180               && !DECL_FROM_INLINE (x)
4181               /* No shadow warnings for internally generated vars.  */
4182               && ! DECL_ARTIFICIAL (x)
4183               /* No shadow warnings for vars made for inlining.  */
4184               && ! DECL_FROM_INLINE (x))
4185             {
4186               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4187                 warning ("declaration of `%s' shadows a parameter",
4188                         IDENTIFIER_POINTER (name));
4189               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4190                        && current_class_ptr
4191                        && !TREE_STATIC (name))
4192                 warning ("declaration of `%s' shadows a member of `this'",
4193                         IDENTIFIER_POINTER (name));
4194               else if (oldlocal != NULL_TREE)
4195                 warning ("declaration of `%s' shadows previous local",
4196                         IDENTIFIER_POINTER (name));
4197               else if (oldglobal != NULL_TREE)
4198                 /* XXX shadow warnings in outer-more namespaces */
4199                 warning ("declaration of `%s' shadows global declaration",
4200                         IDENTIFIER_POINTER (name));
4201             }
4202         }
4203
4204       if (TREE_CODE (x) == FUNCTION_DECL)
4205         check_default_args (x);
4206
4207       /* Keep count of variables in this level with incomplete type.  */
4208       if (TREE_CODE (x) == VAR_DECL
4209           && TREE_TYPE (x) != error_mark_node
4210           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4211                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4212               /* RTTI TD entries are created while defining the type_info.  */
4213               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4214                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4215         {
4216           if (namespace_bindings_p ())
4217             namespace_scope_incomplete
4218               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4219           else
4220             current_binding_level->incomplete
4221               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4222         }
4223     }
4224
4225   if (need_new_binding)
4226     add_decl_to_level (x,
4227                        DECL_NAMESPACE_SCOPE_P (x)
4228                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4229                        : current_binding_level);
4230
4231   return x;
4232 }
4233
4234 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4235    caller to set DECL_CONTEXT properly.  */
4236
4237 static tree
4238 pushdecl_with_scope (x, level)
4239      tree x;
4240      struct binding_level *level;
4241 {
4242   register struct binding_level *b;
4243   tree function_decl = current_function_decl;
4244
4245   current_function_decl = NULL_TREE;
4246   if (level->parm_flag == 2)
4247     {
4248       b = class_binding_level;
4249       class_binding_level = level;
4250       pushdecl_class_level (x);
4251       class_binding_level = b;
4252     }
4253   else
4254     {
4255       b = current_binding_level;
4256       current_binding_level = level;
4257       x = pushdecl (x);
4258       current_binding_level = b;
4259     }
4260   current_function_decl = function_decl;
4261   return x;
4262 }
4263
4264 /* Like pushdecl, only it places X in the current namespace,
4265    if appropriate.  */
4266
4267 tree
4268 pushdecl_namespace_level (x)
4269      tree x;
4270 {
4271   register struct binding_level *b = current_binding_level;
4272   register tree t;
4273
4274   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4275
4276   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4277      what we want.  */
4278   if (TREE_CODE (x) == TYPE_DECL)
4279     {
4280       tree name = DECL_NAME (x);
4281       tree newval;
4282       tree *ptr = (tree *)0;
4283       for (; b != global_binding_level; b = b->level_chain)
4284         {
4285           tree shadowed = b->type_shadowed;
4286           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4287             if (TREE_PURPOSE (shadowed) == name)
4288               {
4289                 ptr = &TREE_VALUE (shadowed);
4290                 /* Can't break out of the loop here because sometimes
4291                    a binding level will have duplicate bindings for
4292                    PT names.  It's gross, but I haven't time to fix it.  */
4293               }
4294         }
4295       newval = TREE_TYPE (x);
4296       if (ptr == (tree *)0)
4297         {
4298           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4299              up here if this is changed to an assertion.  --KR  */
4300           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4301         }
4302       else
4303         {
4304           *ptr = newval;
4305         }
4306     }
4307   return t;
4308 }
4309
4310 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4311    if appropriate.  */
4312
4313 tree
4314 pushdecl_top_level (x)
4315      tree x;
4316 {
4317   push_to_top_level ();
4318   x = pushdecl_namespace_level (x);
4319   pop_from_top_level ();
4320   return x;
4321 }
4322
4323 /* Make the declaration of X appear in CLASS scope.  */
4324
4325 void
4326 pushdecl_class_level (x)
4327      tree x;
4328 {
4329   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4330      scope looks for the pre-mangled name.  */
4331   register tree name;
4332
4333   if (TREE_CODE (x) == OVERLOAD)
4334     x = OVL_CURRENT (x);
4335   name = DECL_NAME (x);
4336
4337   if (name)
4338     {
4339       push_class_level_binding (name, x);
4340       if (TREE_CODE (x) == TYPE_DECL)
4341         set_identifier_type_value (name, TREE_TYPE (x));
4342     }
4343   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4344     {
4345       tree f;
4346
4347       for (f = TYPE_FIELDS (TREE_TYPE (x));
4348            f;
4349            f = TREE_CHAIN (f))
4350         pushdecl_class_level (f);
4351     }
4352 }
4353
4354 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4355    DECL, or a modified version thereof.  */
4356
4357 tree
4358 maybe_push_decl (decl)
4359      tree decl;
4360 {
4361   tree type = TREE_TYPE (decl);
4362
4363   /* Add this decl to the current binding level, but not if it comes
4364      from another scope, e.g. a static member variable.  TEM may equal
4365      DECL or it may be a previous decl of the same name.  */
4366   if (decl == error_mark_node
4367       || (TREE_CODE (decl) != PARM_DECL
4368           && DECL_CONTEXT (decl) != NULL_TREE
4369           /* Definitions of namespace members outside their namespace are
4370              possible. */
4371           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4372       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4373       || TREE_CODE (type) == UNKNOWN_TYPE
4374       /* The declaration of a template specialization does not affect
4375          the functions available for overload resolution, so we do not
4376          call pushdecl.  */
4377       || (TREE_CODE (decl) == FUNCTION_DECL
4378           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4379     return decl;
4380   else
4381     return pushdecl (decl);
4382 }
4383
4384 /* Make the declaration(s) of X appear in CLASS scope
4385    under the name NAME.  */
4386
4387 void
4388 push_class_level_binding (name, x)
4389      tree name;
4390      tree x;
4391 {
4392   tree binding;
4393   /* The class_binding_level will be NULL if x is a template
4394      parameter name in a member template.  */
4395   if (!class_binding_level)
4396     return;
4397
4398   /* Make sure that this new member does not have the same name
4399      as a template parameter.  */
4400   if (TYPE_BEING_DEFINED (current_class_type))
4401     check_template_shadow (x);
4402
4403   /* If this declaration shadows a declaration from an enclosing
4404      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4405      we leave this class.  Record the shadowed declaration here.  */
4406   binding = IDENTIFIER_BINDING (name);
4407   if (binding
4408       && ((TREE_CODE (x) == OVERLOAD
4409            && BINDING_VALUE (binding)
4410            && is_overloaded_fn (BINDING_VALUE (binding)))
4411           || INHERITED_VALUE_BINDING_P (binding)))
4412     {
4413       tree shadow;
4414       tree old_decl;
4415
4416       /* If the old binding was from a base class, and was for a tag
4417          name, slide it over to make room for the new binding.  The
4418          old binding is still visible if explicitly qualified with a
4419          class-key.  */
4420       if (INHERITED_VALUE_BINDING_P (binding)
4421           && BINDING_VALUE (binding)
4422           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4423           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4424           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4425         {
4426           old_decl = BINDING_TYPE (binding);
4427           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4428           BINDING_VALUE (binding) = NULL_TREE;
4429           INHERITED_VALUE_BINDING_P (binding) = 0;
4430         }
4431       else
4432         old_decl = BINDING_VALUE (binding);
4433
4434       /* There was already a binding for X containing fewer
4435          functions than are named in X.  Find the previous
4436          declaration of X on the class-shadowed list, and update it.  */
4437       for (shadow = class_binding_level->class_shadowed;
4438            shadow;
4439            shadow = TREE_CHAIN (shadow))
4440         if (TREE_PURPOSE (shadow) == name
4441             && TREE_TYPE (shadow) == old_decl)
4442           {
4443             BINDING_VALUE (binding) = x;
4444             INHERITED_VALUE_BINDING_P (binding) = 0;
4445             TREE_TYPE (shadow) = x;
4446             return;
4447           }
4448     }
4449
4450   /* If we didn't replace an existing binding, put the binding on the
4451      stack of bindings for the identifier, and update
4452      IDENTIFIER_CLASS_VALUE.  */
4453   if (push_class_binding (name, x))
4454     {
4455       class_binding_level->class_shadowed
4456         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4457                      class_binding_level->class_shadowed);
4458       /* Record the value we are binding NAME to so that we can know
4459          what to pop later.  */
4460       TREE_TYPE (class_binding_level->class_shadowed) = x;
4461     }
4462 }
4463
4464 /* Insert another USING_DECL into the current binding level, returning
4465    this declaration. If this is a redeclaration, do nothing, and
4466    return NULL_TREE if this not in namespace scope (in namespace
4467    scope, a using decl might extend any previous bindings).  */
4468
4469 tree
4470 push_using_decl (scope, name)
4471      tree scope;
4472      tree name;
4473 {
4474   tree decl;
4475
4476   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4477   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4478   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4479     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4480       break;
4481   if (decl)
4482     return namespace_bindings_p () ? decl : NULL_TREE;
4483   decl = build_lang_decl (USING_DECL, name, void_type_node);
4484   DECL_INITIAL (decl) = scope;
4485   TREE_CHAIN (decl) = current_binding_level->usings;
4486   current_binding_level->usings = decl;
4487   return decl;
4488 }
4489
4490 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4491    changed (i.e. there was already a directive), or the fresh
4492    TREE_LIST otherwise.  */
4493
4494 tree
4495 push_using_directive (used)
4496      tree used;
4497 {
4498   tree ud = current_binding_level->using_directives;
4499   tree iter, ancestor;
4500
4501   /* Check if we already have this. */
4502   if (purpose_member (used, ud) != NULL_TREE)
4503     return NULL_TREE;
4504
4505   /* Recursively add all namespaces used. */
4506   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4507     push_using_directive (TREE_PURPOSE (iter));
4508
4509   ancestor = namespace_ancestor (current_decl_namespace (), used);
4510   ud = current_binding_level->using_directives;
4511   ud = tree_cons (used, ancestor, ud);
4512   current_binding_level->using_directives = ud;
4513   return ud;
4514 }
4515
4516 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4517    other definitions already in place.  We get around this by making
4518    the value of the identifier point to a list of all the things that
4519    want to be referenced by that name.  It is then up to the users of
4520    that name to decide what to do with that list.
4521
4522    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4523    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4524
4525    FLAGS is a bitwise-or of the following values:
4526      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4527                  namespace scope.
4528      PUSH_USING: DECL is being pushed as the result of a using
4529                  declaration.
4530
4531    The value returned may be a previous declaration if we guessed wrong
4532    about what language DECL should belong to (C or C++).  Otherwise,
4533    it's always DECL (and never something that's not a _DECL).  */
4534
4535 tree
4536 push_overloaded_decl (decl, flags)
4537      tree decl;
4538      int flags;
4539 {
4540   tree name = DECL_NAME (decl);
4541   tree old;
4542   tree new_binding;
4543   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4544
4545   if (doing_global)
4546     old = namespace_binding (name, DECL_CONTEXT (decl));
4547   else
4548     old = lookup_name_current_level (name);
4549
4550   if (old)
4551     {
4552       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4553         {
4554           tree t = TREE_TYPE (old);
4555           if (IS_AGGR_TYPE (t) && warn_shadow
4556               && (! DECL_IN_SYSTEM_HEADER (decl)
4557                   || ! DECL_IN_SYSTEM_HEADER (old)))
4558             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4559           old = NULL_TREE;
4560         }
4561       else if (is_overloaded_fn (old))
4562         {
4563           tree tmp;
4564
4565           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4566             {
4567               tree fn = OVL_CURRENT (tmp);
4568
4569               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4570                   && !(flags & PUSH_USING)
4571                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4572                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4573                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4574                           decl, fn);
4575
4576               if (duplicate_decls (decl, fn))
4577                 return fn;
4578             }
4579         }
4580       else
4581         {
4582           cp_error_at ("previous non-function declaration `%#D'", old);
4583           cp_error ("conflicts with function declaration `%#D'", decl);
4584           return decl;
4585         }
4586     }
4587
4588   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4589     {
4590       if (old && TREE_CODE (old) != OVERLOAD)
4591         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4592       else
4593         new_binding = ovl_cons (decl, old);
4594       if (flags & PUSH_USING)
4595         OVL_USED (new_binding) = 1;
4596     }
4597   else
4598     /* NAME is not ambiguous.  */
4599     new_binding = decl;
4600
4601   if (doing_global)
4602     set_namespace_binding (name, current_namespace, new_binding);
4603   else
4604     {
4605       /* We only create an OVERLOAD if there was a previous binding at
4606          this level, or if decl is a template. In the former case, we
4607          need to remove the old binding and replace it with the new
4608          binding.  We must also run through the NAMES on the binding
4609          level where the name was bound to update the chain.  */
4610
4611       if (TREE_CODE (new_binding) == OVERLOAD && old)
4612         {
4613           tree *d;
4614
4615           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4616                *d;
4617                d = &TREE_CHAIN (*d))
4618             if (*d == old
4619                 || (TREE_CODE (*d) == TREE_LIST
4620                     && TREE_VALUE (*d) == old))
4621               {
4622                 if (TREE_CODE (*d) == TREE_LIST)
4623                   /* Just replace the old binding with the new.  */
4624                   TREE_VALUE (*d) = new_binding;
4625                 else
4626                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4627                   *d = tree_cons (NULL_TREE, new_binding,
4628                                   TREE_CHAIN (*d));
4629
4630                 /* And update the CPLUS_BINDING node.  */
4631                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4632                   = new_binding;
4633                 return decl;
4634               }
4635
4636           /* We should always find a previous binding in this case.  */
4637           my_friendly_abort (0);
4638         }
4639
4640       /* Install the new binding.  */
4641       push_local_binding (name, new_binding, flags);
4642     }
4643
4644   return decl;
4645 }
4646 \f
4647 /* Generate an implicit declaration for identifier FUNCTIONID
4648    as a function of type int ().  Print a warning if appropriate.  */
4649
4650 tree
4651 implicitly_declare (functionid)
4652      tree functionid;
4653 {
4654   register tree decl;
4655
4656   /* We used to reuse an old implicit decl here,
4657      but this loses with inline functions because it can clobber
4658      the saved decl chains.  */
4659   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4660
4661   DECL_EXTERNAL (decl) = 1;
4662   TREE_PUBLIC (decl) = 1;
4663
4664   /* ISO standard says implicit declarations are in the innermost block.
4665      So we record the decl in the standard fashion.  */
4666   pushdecl (decl);
4667   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4668
4669   if (warn_implicit
4670       /* Only one warning per identifier.  */
4671       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4672     {
4673       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4674     }
4675
4676   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4677
4678   return decl;
4679 }
4680
4681 /* Return zero if the declaration NEWDECL is valid
4682    when the declaration OLDDECL (assumed to be for the same name)
4683    has already been seen.
4684    Otherwise return an error message format string with a %s
4685    where the identifier should go.  */
4686
4687 static const char *
4688 redeclaration_error_message (newdecl, olddecl)
4689      tree newdecl, olddecl;
4690 {
4691   if (TREE_CODE (newdecl) == TYPE_DECL)
4692     {
4693       /* Because C++ can put things into name space for free,
4694          constructs like "typedef struct foo { ... } foo"
4695          would look like an erroneous redeclaration.  */
4696       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4697         return 0;
4698       else
4699         return "redefinition of `%#D'";
4700     }
4701   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4702     {
4703       /* If this is a pure function, its olddecl will actually be
4704          the original initialization to `0' (which we force to call
4705          abort()).  Don't complain about redefinition in this case.  */
4706       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4707         return 0;
4708
4709       /* If both functions come from different namespaces, this is not
4710          a redeclaration - this is a conflict with a used function. */
4711       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4712           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4713         return "`%D' conflicts with used function";
4714
4715       /* We'll complain about linkage mismatches in
4716          warn_extern_redeclared_static.  */
4717
4718       /* Defining the same name twice is no good.  */
4719       if (DECL_INITIAL (olddecl) != NULL_TREE
4720           && DECL_INITIAL (newdecl) != NULL_TREE)
4721         {
4722           if (DECL_NAME (olddecl) == NULL_TREE)
4723             return "`%#D' not declared in class";
4724           else
4725             return "redefinition of `%#D'";
4726         }
4727       return 0;
4728     }
4729   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4730     {
4731       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4732            && (DECL_TEMPLATE_RESULT (newdecl)
4733                != DECL_TEMPLATE_RESULT (olddecl))
4734            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4735            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4736           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4737               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4738               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4739         return "redefinition of `%#D'";
4740       return 0;
4741     }
4742   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4743     {
4744       /* Objects declared at top level:  */
4745       /* If at least one is a reference, it's ok.  */
4746       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4747         return 0;
4748       /* Reject two definitions.  */
4749       return "redefinition of `%#D'";
4750     }
4751   else
4752     {
4753       /* Objects declared with block scope:  */
4754       /* Reject two definitions, and reject a definition
4755          together with an external reference.  */
4756       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4757         return "redeclaration of `%#D'";
4758       return 0;
4759     }
4760 }
4761 \f
4762 /* Create a new label, named ID.  */
4763
4764 static tree
4765 make_label_decl (id, local_p)
4766      tree id;
4767      int local_p;
4768 {
4769   tree decl;
4770
4771   decl = build_decl (LABEL_DECL, id, void_type_node);
4772   if (expanding_p)
4773     /* Make sure every label has an rtx.  */
4774     label_rtx (decl);
4775
4776   DECL_CONTEXT (decl) = current_function_decl;
4777   DECL_MODE (decl) = VOIDmode;
4778   C_DECLARED_LABEL_FLAG (decl) = local_p;
4779
4780   /* Say where one reference is to the label, for the sake of the
4781      error if it is not defined.  */
4782   DECL_SOURCE_LINE (decl) = lineno;
4783   DECL_SOURCE_FILE (decl) = input_filename;
4784
4785   /* Record the fact that this identifier is bound to this label.  */
4786   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4787
4788   return decl;
4789 }
4790
4791 /* Record this label on the list of used labels so that we can check
4792    at the end of the function to see whether or not the label was
4793    actually defined, and so we can check when the label is defined whether
4794    this use is valid.  */
4795
4796 static void
4797 use_label (decl)
4798      tree decl;
4799 {
4800   if (named_label_uses == NULL
4801       || named_label_uses->names_in_scope != current_binding_level->names
4802       || named_label_uses->label_decl != decl)
4803     {
4804       struct named_label_use_list *new_ent;
4805       new_ent = ((struct named_label_use_list *)
4806                  ggc_alloc (sizeof (struct named_label_use_list)));
4807       new_ent->label_decl = decl;
4808       new_ent->names_in_scope = current_binding_level->names;
4809       new_ent->binding_level = current_binding_level;
4810       new_ent->lineno_o_goto = lineno;
4811       new_ent->filename_o_goto = input_filename;
4812       new_ent->next = named_label_uses;
4813       named_label_uses = new_ent;
4814     }
4815 }
4816
4817 /* Look for a label named ID in the current function.  If one cannot
4818    be found, create one.  (We keep track of used, but undefined,
4819    labels, and complain about them at the end of a function.)  */
4820
4821 tree
4822 lookup_label (id)
4823      tree id;
4824 {
4825   tree decl;
4826   struct named_label_list *ent;
4827
4828   /* You can't use labels at global scope.  */
4829   if (current_function_decl == NULL_TREE)
4830     {
4831       error ("label `%s' referenced outside of any function",
4832              IDENTIFIER_POINTER (id));
4833       return NULL_TREE;
4834     }
4835
4836   /* See if we've already got this label.  */
4837   decl = IDENTIFIER_LABEL_VALUE (id);
4838   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4839     return decl;
4840
4841   /* Record this label on the list of labels used in this function.
4842      We do this before calling make_label_decl so that we get the
4843      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4844   ent = ((struct named_label_list *)
4845          ggc_alloc_obj (sizeof (struct named_label_list), 1));
4846   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4847   ent->next = named_labels;
4848   named_labels = ent;
4849
4850   /* We need a new label.  */
4851   decl = make_label_decl (id, /*local_p=*/0);
4852
4853   /* Now fill in the information we didn't have before.  */
4854   ent->label_decl = decl;
4855
4856   return decl;
4857 }
4858
4859 /* Declare a local label named ID.  */
4860
4861 tree
4862 declare_local_label (id)
4863      tree id;
4864 {
4865   tree decl;
4866
4867   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4868      this scope we can restore the old value of
4869      IDENTIFIER_TYPE_VALUE.  */
4870   current_binding_level->shadowed_labels
4871     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4872                  current_binding_level->shadowed_labels);
4873   /* Look for the label.  */
4874   decl = make_label_decl (id, /*local_p=*/1);
4875   /* Now fill in the information we didn't have before.  */
4876   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4877
4878   return decl;
4879 }
4880
4881 /* Returns nonzero if it is ill-formed to jump past the declaration of
4882    DECL.  Returns 2 if it's also a real problem.  */
4883
4884 static int
4885 decl_jump_unsafe (decl)
4886      tree decl;
4887 {
4888   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4889     return 0;
4890
4891   if (DECL_INITIAL (decl) == NULL_TREE
4892       && pod_type_p (TREE_TYPE (decl)))
4893     return 0;
4894
4895   /* This is really only important if we're crossing an initialization.
4896      The POD stuff is just pedantry; why should it matter if the class
4897      contains a field of pointer to member type?  */
4898   if (DECL_INITIAL (decl)
4899       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4900     return 2;
4901   return 1;
4902 }
4903
4904 /* Check that a single previously seen jump to a newly defined label
4905    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4906    the jump context; NAMES are the names in scope in LEVEL at the jump
4907    context; FILE and LINE are the source position of the jump or 0.  */
4908
4909 static void
4910 check_previous_goto_1 (decl, level, names, file, line)
4911      tree decl;
4912      struct binding_level *level;
4913      tree names;
4914      const char *file;
4915      int line;
4916 {
4917   int identified = 0;
4918   int saw_eh = 0;
4919   struct binding_level *b = current_binding_level;
4920   for (; b; b = b->level_chain)
4921     {
4922       tree new_decls = b->names;
4923       tree old_decls = (b == level ? names : NULL_TREE);
4924       for (; new_decls != old_decls;
4925            new_decls = TREE_CHAIN (new_decls))
4926         {
4927           int problem = decl_jump_unsafe (new_decls);
4928           if (! problem)
4929             continue;
4930
4931           if (! identified)
4932             {
4933               if (decl)
4934                 cp_pedwarn ("jump to label `%D'", decl);
4935               else
4936                 pedwarn ("jump to case label");
4937
4938               if (file)
4939                 pedwarn_with_file_and_line (file, line, "  from here");
4940               identified = 1;
4941             }
4942
4943           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4944             /* Can't skip init of __exception_info.  */
4945             cp_error_at ("  enters catch block", new_decls);
4946           else if (problem > 1)
4947             cp_error_at ("  crosses initialization of `%#D'",
4948                          new_decls);
4949           else
4950             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4951                            new_decls);
4952         }
4953
4954       if (b == level)
4955         break;
4956       if (b->eh_region && ! saw_eh)
4957         {
4958           if (! identified)
4959             {
4960               if (decl)
4961                 cp_pedwarn ("jump to label `%D'", decl);
4962               else
4963                 pedwarn ("jump to case label");
4964
4965               if (file)
4966                 pedwarn_with_file_and_line (file, line, "  from here");
4967               identified = 1;
4968             }
4969           error ("  enters try block");
4970           saw_eh = 1;
4971         }
4972     }
4973 }
4974
4975 static void
4976 check_previous_goto (use)
4977      struct named_label_use_list *use;
4978 {
4979   check_previous_goto_1 (use->label_decl, use->binding_level,
4980                          use->names_in_scope, use->filename_o_goto,
4981                          use->lineno_o_goto);
4982 }
4983
4984 static void
4985 check_switch_goto (level)
4986      struct binding_level *level;
4987 {
4988   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4989 }
4990
4991 /* Check that any previously seen jumps to a newly defined label DECL
4992    are OK.  Called by define_label.  */
4993
4994 static void
4995 check_previous_gotos (decl)
4996      tree decl;
4997 {
4998   struct named_label_use_list **usep;
4999
5000   if (! TREE_USED (decl))
5001     return;
5002
5003   for (usep = &named_label_uses; *usep; )
5004     {
5005       struct named_label_use_list *use = *usep;
5006       if (use->label_decl == decl)
5007         {
5008           check_previous_goto (use);
5009           *usep = use->next;
5010         }
5011       else
5012         usep = &(use->next);
5013     }
5014 }
5015
5016 /* Check that a new jump to a label DECL is OK.  Called by
5017    finish_goto_stmt.  */
5018
5019 void
5020 check_goto (decl)
5021      tree decl;
5022 {
5023   int identified = 0;
5024   tree bad;
5025   struct named_label_list *lab;
5026
5027   /* If the label hasn't been defined yet, defer checking.  */
5028   if (! DECL_INITIAL (decl))
5029     {
5030       use_label (decl);
5031       return;
5032     }
5033
5034   for (lab = named_labels; lab; lab = lab->next)
5035     if (decl == lab->label_decl)
5036       break;
5037
5038   /* If the label is not on named_labels it's a gcc local label, so
5039      it must be in an outer scope, so jumping to it is always OK.  */
5040   if (lab == 0)
5041     return;
5042
5043   if ((lab->eh_region || lab->bad_decls) && !identified)
5044     {
5045       cp_pedwarn_at ("jump to label `%D'", decl);
5046       pedwarn ("  from here");
5047       identified = 1;
5048     }
5049
5050   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5051     {
5052       tree b = TREE_VALUE (bad);
5053       int u = decl_jump_unsafe (b);
5054
5055       if (u > 1 && DECL_ARTIFICIAL (b))
5056         /* Can't skip init of __exception_info.  */
5057         cp_error_at ("  enters catch block", b);
5058       else if (u > 1)
5059         cp_error_at ("  skips initialization of `%#D'", b);
5060       else
5061         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5062     }
5063
5064   if (lab->eh_region)
5065     error ("  enters try block");
5066 }
5067
5068 /* Define a label, specifying the location in the source file.
5069    Return the LABEL_DECL node for the label, if the definition is valid.
5070    Otherwise return 0.  */
5071
5072 tree
5073 define_label (filename, line, name)
5074      const char *filename;
5075      int line;
5076      tree name;
5077 {
5078   tree decl = lookup_label (name);
5079   struct named_label_list *ent;
5080
5081   for (ent = named_labels; ent; ent = ent->next)
5082     if (ent->label_decl == decl)
5083       break;
5084
5085   /* After labels, make any new cleanups go into their
5086      own new (temporary) binding contour.  */
5087   current_binding_level->more_cleanups_ok = 0;
5088
5089   if (name == get_identifier ("wchar_t"))
5090     cp_pedwarn ("label named wchar_t");
5091
5092   if (DECL_INITIAL (decl) != NULL_TREE)
5093     {
5094       cp_error ("duplicate label `%D'", decl);
5095       return 0;
5096     }
5097   else
5098     {
5099       /* Mark label as having been defined.  */
5100       DECL_INITIAL (decl) = error_mark_node;
5101       /* Say where in the source.  */
5102       DECL_SOURCE_FILE (decl) = filename;
5103       DECL_SOURCE_LINE (decl) = line;
5104       if (ent)
5105         {
5106           ent->names_in_scope = current_binding_level->names;
5107           ent->binding_level = current_binding_level;
5108         }
5109       check_previous_gotos (decl);
5110       current_function_return_value = NULL_TREE;
5111       return decl;
5112     }
5113 }
5114
5115 struct cp_switch
5116 {
5117   struct binding_level *level;
5118   struct cp_switch *next;
5119 };
5120
5121 static struct cp_switch *switch_stack;
5122
5123 void
5124 push_switch ()
5125 {
5126   struct cp_switch *p
5127     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5128   p->level = current_binding_level;
5129   p->next = switch_stack;
5130   switch_stack = p;
5131 }
5132
5133 void
5134 pop_switch ()
5135 {
5136   struct cp_switch *cs;
5137
5138   cs = switch_stack;
5139   switch_stack = switch_stack->next;
5140   free (cs);
5141 }
5142
5143 /* Note that we've seen a definition of a case label, and complain if this
5144    is a bad place for one.  */
5145
5146 void
5147 define_case_label ()
5148 {
5149   tree cleanup = last_cleanup_this_contour ();
5150
5151   if (! switch_stack)
5152     /* Don't crash; we'll complain in do_case.  */
5153     return;
5154
5155   if (cleanup)
5156     {
5157       static int explained = 0;
5158       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5159       warning ("where case label appears here");
5160       if (!explained)
5161         {
5162           warning ("(enclose actions of previous case statements requiring");
5163           warning ("destructors in their own binding contours.)");
5164           explained = 1;
5165         }
5166     }
5167
5168   check_switch_goto (switch_stack->level);
5169
5170   /* After labels, make any new cleanups go into their
5171      own new (temporary) binding contour.  */
5172
5173   current_binding_level->more_cleanups_ok = 0;
5174   current_function_return_value = NULL_TREE;
5175 }
5176 \f
5177 /* Return the list of declarations of the current level.
5178    Note that this list is in reverse order unless/until
5179    you nreverse it; and when you do nreverse it, you must
5180    store the result back using `storedecls' or you will lose.  */
5181
5182 tree
5183 getdecls ()
5184 {
5185   return current_binding_level->names;
5186 }
5187
5188 /* Return the list of type-tags (for structs, etc) of the current level.  */
5189
5190 tree
5191 gettags ()
5192 {
5193   return current_binding_level->tags;
5194 }
5195
5196 /* Store the list of declarations of the current level.
5197    This is done for the parameter declarations of a function being defined,
5198    after they are modified in the light of any missing parameters.  */
5199
5200 static void
5201 storedecls (decls)
5202      tree decls;
5203 {
5204   current_binding_level->names = decls;
5205 }
5206
5207 /* Similarly, store the list of tags of the current level.  */
5208
5209 void
5210 storetags (tags)
5211      tree tags;
5212 {
5213   current_binding_level->tags = tags;
5214 }
5215 \f
5216 /* Given NAME, an IDENTIFIER_NODE,
5217    return the structure (or union or enum) definition for that name.
5218    Searches binding levels from BINDING_LEVEL up to the global level.
5219    If THISLEVEL_ONLY is nonzero, searches only the specified context
5220    (but skips any tag-transparent contexts to find one that is
5221    meaningful for tags).
5222    FORM says which kind of type the caller wants;
5223    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5224    If the wrong kind of type is found, and it's not a template, an error is
5225    reported.  */
5226
5227 static tree
5228 lookup_tag (form, name, binding_level, thislevel_only)
5229      enum tree_code form;
5230      tree name;
5231      struct binding_level *binding_level;
5232      int thislevel_only;
5233 {
5234   register struct binding_level *level;
5235   /* Non-zero if, we should look past a template parameter level, even
5236      if THISLEVEL_ONLY.  */
5237   int allow_template_parms_p = 1;
5238
5239   for (level = binding_level; level; level = level->level_chain)
5240     {
5241       register tree tail;
5242       if (ANON_AGGRNAME_P (name))
5243         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5244           {
5245             /* There's no need for error checking here, because
5246                anon names are unique throughout the compilation.  */
5247             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5248               return TREE_VALUE (tail);
5249           }
5250       else if (level->namespace_p)
5251         /* Do namespace lookup. */
5252         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5253           {
5254             tree old = binding_for_name (name, tail);
5255
5256             /* If we just skipped past a template parameter level,
5257                even though THISLEVEL_ONLY, and we find a template
5258                class declaration, then we use the _TYPE node for the
5259                template.  See the example below.  */
5260             if (thislevel_only && !allow_template_parms_p
5261                 && old && BINDING_VALUE (old)
5262                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5263               old = TREE_TYPE (BINDING_VALUE (old));
5264             else
5265               old = BINDING_TYPE (old);
5266
5267             /* If it has an original type, it is a typedef, and we
5268                should not return it.  */
5269             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5270               old = NULL_TREE;
5271             if (old && TREE_CODE (old) != form
5272                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5273               {
5274                 cp_error ("`%#D' redeclared as %C", old, form);
5275                 return NULL_TREE;
5276               }
5277             if (old)
5278               return old;
5279             if (thislevel_only || tail == global_namespace)
5280               return NULL_TREE;
5281           }
5282       else
5283         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5284           {
5285             if (TREE_PURPOSE (tail) == name)
5286               {
5287                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5288                 /* Should tighten this up; it'll probably permit
5289                    UNION_TYPE and a struct template, for example.  */
5290                 if (code != form
5291                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5292                   {
5293                     /* Definition isn't the kind we were looking for.  */
5294                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5295                               form);
5296                     return NULL_TREE;
5297                   }
5298                 return TREE_VALUE (tail);
5299               }
5300           }
5301       if (thislevel_only && ! level->tag_transparent)
5302         {
5303           if (level->template_parms_p && allow_template_parms_p)
5304             {
5305               /* We must deal with cases like this:
5306
5307                    template <class T> struct S;
5308                    template <class T> struct S {};
5309
5310                  When looking up `S', for the second declaration, we
5311                  would like to find the first declaration.  But, we
5312                  are in the pseudo-global level created for the
5313                  template parameters, rather than the (surrounding)
5314                  namespace level.  Thus, we keep going one more level,
5315                  even though THISLEVEL_ONLY is non-zero.  */
5316               allow_template_parms_p = 0;
5317               continue;
5318             }
5319           else
5320             return NULL_TREE;
5321         }
5322     }
5323   return NULL_TREE;
5324 }
5325
5326 #if 0
5327 void
5328 set_current_level_tags_transparency (tags_transparent)
5329      int tags_transparent;
5330 {
5331   current_binding_level->tag_transparent = tags_transparent;
5332 }
5333 #endif
5334
5335 /* Given a type, find the tag that was defined for it and return the tag name.
5336    Otherwise return 0.  However, the value can never be 0
5337    in the cases in which this is used.
5338
5339    C++: If NAME is non-zero, this is the new name to install.  This is
5340    done when replacing anonymous tags with real tag names.  */
5341
5342 static tree
5343 lookup_tag_reverse (type, name)
5344      tree type;
5345      tree name;
5346 {
5347   register struct binding_level *level;
5348
5349   for (level = current_binding_level; level; level = level->level_chain)
5350     {
5351       register tree tail;
5352       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5353         {
5354           if (TREE_VALUE (tail) == type)
5355             {
5356               if (name)
5357                 TREE_PURPOSE (tail) = name;
5358               return TREE_PURPOSE (tail);
5359             }
5360         }
5361     }
5362   return NULL_TREE;
5363 }
5364 \f
5365 /* Look up NAME in the NAMESPACE.  */
5366
5367 tree
5368 lookup_namespace_name (namespace, name)
5369      tree namespace, name;
5370 {
5371   tree val;
5372   tree template_id = NULL_TREE;
5373
5374   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5375
5376   if (TREE_CODE (name) == NAMESPACE_DECL)
5377     /* This happens for A::B<int> when B is a namespace. */
5378     return name;
5379   else if (TREE_CODE (name) == TEMPLATE_DECL)
5380     {
5381       /* This happens for A::B where B is a template, and there are no
5382          template arguments.  */
5383       cp_error ("invalid use of `%D'", name);
5384       return error_mark_node;
5385     }
5386
5387   namespace = ORIGINAL_NAMESPACE (namespace);
5388
5389   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5390     {
5391       template_id = name;
5392       name = TREE_OPERAND (name, 0);
5393       if (TREE_CODE (name) == OVERLOAD)
5394         name = DECL_NAME (OVL_CURRENT (name));
5395       else if (DECL_P (name))
5396         name = DECL_NAME (name);
5397     }
5398
5399   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5400
5401   val = make_node (CPLUS_BINDING);
5402   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5403     return error_mark_node;
5404
5405   if (BINDING_VALUE (val))
5406     {
5407       val = BINDING_VALUE (val);
5408
5409       if (template_id)
5410         {
5411           if (DECL_CLASS_TEMPLATE_P (val))
5412             val = lookup_template_class (val,
5413                                          TREE_OPERAND (template_id, 1),
5414                                          /*in_decl=*/NULL_TREE,
5415                                          /*context=*/NULL_TREE,
5416                                          /*entering_scope=*/0);
5417           else if (DECL_FUNCTION_TEMPLATE_P (val)
5418                    || TREE_CODE (val) == OVERLOAD)
5419             val = lookup_template_function (val,
5420                                             TREE_OPERAND (template_id, 1));
5421           else
5422             {
5423               cp_error ("`%D::%D' is not a template",
5424                         namespace, name);
5425               return error_mark_node;
5426             }
5427         }
5428
5429       /* If we have a single function from a using decl, pull it out.  */
5430       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5431         val = OVL_FUNCTION (val);
5432       return val;
5433     }
5434
5435   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5436   return error_mark_node;
5437 }
5438
5439 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5440
5441 static unsigned long
5442 typename_hash (k)
5443      hash_table_key k;
5444 {
5445   unsigned long hash;
5446   tree t;
5447
5448   t = (tree) k;
5449   hash = (((unsigned long) TYPE_CONTEXT (t))
5450           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5451
5452   return hash;
5453 }
5454
5455 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5456
5457 static boolean
5458 typename_compare (k1, k2)
5459      hash_table_key k1;
5460      hash_table_key k2;
5461 {
5462   tree t1;
5463   tree t2;
5464   tree d1;
5465   tree d2;
5466
5467   t1 = (tree) k1;
5468   t2 = (tree) k2;
5469   d1 = TYPE_NAME (t1);
5470   d2 = TYPE_NAME (t2);
5471
5472   return (DECL_NAME (d1) == DECL_NAME (d2)
5473           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5474           && ((TREE_TYPE (t1) != NULL_TREE)
5475               == (TREE_TYPE (t2) != NULL_TREE))
5476           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5477           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5478 }
5479
5480 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5481    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5482    is non-NULL, this type is being created by the implicit typename
5483    extension, and BASE_TYPE is a type named `t' in some base class of
5484    `T' which depends on template parameters.
5485
5486    Returns the new TYPENAME_TYPE.  */
5487
5488 tree
5489 build_typename_type (context, name, fullname, base_type)
5490      tree context;
5491      tree name;
5492      tree fullname;
5493      tree base_type;
5494 {
5495   tree t;
5496   tree d;
5497   struct hash_entry* e;
5498
5499   static struct hash_table ht;
5500
5501   if (!ht.table)
5502     {
5503       static struct hash_table *h = &ht;
5504       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5505                             &typename_compare))
5506         fatal ("virtual memory exhausted");
5507       ggc_add_tree_hash_table_root (&h, 1);
5508     }
5509
5510   /* Build the TYPENAME_TYPE.  */
5511   t = make_aggr_type (TYPENAME_TYPE);
5512   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5513   TYPENAME_TYPE_FULLNAME (t) = fullname;
5514   TREE_TYPE (t) = base_type;
5515
5516   /* Build the corresponding TYPE_DECL.  */
5517   d = build_decl (TYPE_DECL, name, t);
5518   TYPE_NAME (TREE_TYPE (d)) = d;
5519   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5520   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5521   DECL_ARTIFICIAL (d) = 1;
5522
5523   /* See if we already have this type.  */
5524   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5525   if (e)
5526     t = (tree) e->key;
5527   else
5528     /* Insert the type into the table.  */
5529     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5530
5531   return t;
5532 }
5533
5534 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5535    unless an error occurs, in which case error_mark_node is returned.
5536    If COMPLAIN zero, don't complain about any errors that occur.  */
5537
5538 tree
5539 make_typename_type (context, name, complain)
5540      tree context, name;
5541      int complain;
5542 {
5543   tree fullname;
5544
5545   if (TYPE_P (name))
5546     {
5547       if (!(TYPE_LANG_SPECIFIC (name)
5548             && (CLASSTYPE_IS_TEMPLATE (name)
5549                 || CLASSTYPE_USE_TEMPLATE (name))))
5550         name = TYPE_IDENTIFIER (name);
5551       else
5552         /* Create a TEMPLATE_ID_EXPR for the type.  */
5553         name = build_nt (TEMPLATE_ID_EXPR,
5554                          CLASSTYPE_TI_TEMPLATE (name),
5555                          CLASSTYPE_TI_ARGS (name));
5556     }
5557   else if (TREE_CODE (name) == TYPE_DECL)
5558     name = DECL_NAME (name);
5559
5560   fullname = name;
5561
5562   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5563     {
5564       name = TREE_OPERAND (name, 0);
5565       if (TREE_CODE (name) == TEMPLATE_DECL)
5566         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5567     }
5568   if (TREE_CODE (name) != IDENTIFIER_NODE)
5569     my_friendly_abort (2000);
5570
5571   if (TREE_CODE (context) == NAMESPACE_DECL)
5572     {
5573       /* We can get here from typename_sub0 in the explicit_template_type
5574          expansion.  Just fail.  */
5575       if (complain)
5576         cp_error ("no class template named `%#T' in `%#T'",
5577                   name, context);
5578       return error_mark_node;
5579     }
5580
5581   if (! uses_template_parms (context)
5582       || currently_open_class (context))
5583     {
5584       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5585         {
5586           tree tmpl = NULL_TREE;
5587           if (IS_AGGR_TYPE (context))
5588             tmpl = lookup_field (context, name, 0, 0);
5589           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5590             {
5591               if (complain)
5592                 cp_error ("no class template named `%#T' in `%#T'",
5593                           name, context);
5594               return error_mark_node;
5595             }
5596
5597           return lookup_template_class (tmpl,
5598                                         TREE_OPERAND (fullname, 1),
5599                                         NULL_TREE, context,
5600                                         /*entering_scope=*/0);
5601         }
5602       else
5603         {
5604           tree t;
5605
5606           if (!IS_AGGR_TYPE (context))
5607             {
5608               if (complain)
5609                 cp_error ("no type named `%#T' in `%#T'", name, context);
5610               return error_mark_node;
5611             }
5612
5613           t = lookup_field (context, name, 0, 1);
5614           if (t)
5615             return TREE_TYPE (t);
5616         }
5617     }
5618
5619   /* If the CONTEXT is not a template type, then either the field is
5620      there now or its never going to be.  */
5621   if (!uses_template_parms (context))
5622     {
5623       if (complain)
5624         cp_error ("no type named `%#T' in `%#T'", name, context);
5625       return error_mark_node;
5626     }
5627
5628
5629   return build_typename_type (context, name, fullname,  NULL_TREE);
5630 }
5631
5632 /* Select the right _DECL from multiple choices. */
5633
5634 static tree
5635 select_decl (binding, flags)
5636      tree binding;
5637      int flags;
5638 {
5639   tree val;
5640   val = BINDING_VALUE (binding);
5641   if (LOOKUP_NAMESPACES_ONLY (flags))
5642     {
5643       /* We are not interested in types. */
5644       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5645         return val;
5646       return NULL_TREE;
5647     }
5648
5649   /* If we could have a type and
5650      we have nothing or we need a type and have none.  */
5651   if (BINDING_TYPE (binding)
5652       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5653                    && TREE_CODE (val) != TYPE_DECL)))
5654     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5655   /* Don't return non-types if we really prefer types. */
5656   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5657            && (TREE_CODE (val) != TEMPLATE_DECL
5658                || !DECL_CLASS_TEMPLATE_P (val)))
5659     val = NULL_TREE;
5660
5661   return val;
5662 }
5663
5664 /* Unscoped lookup of a global: iterate over current namespaces,
5665    considering using-directives.  If SPACESP is non-NULL, store a list
5666    of the namespaces we've considered in it.  */
5667
5668 tree
5669 unqualified_namespace_lookup (name, flags, spacesp)
5670      tree name;
5671      int flags;
5672      tree *spacesp;
5673 {
5674   tree b = make_node (CPLUS_BINDING);
5675   tree initial = current_decl_namespace();
5676   tree scope = initial;
5677   tree siter;
5678   struct binding_level *level;
5679   tree val = NULL_TREE;
5680
5681   if (spacesp)
5682     *spacesp = NULL_TREE;
5683
5684   for (; !val; scope = CP_DECL_CONTEXT (scope))
5685     {
5686       if (spacesp)
5687         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5688       val = binding_for_name (name, scope);
5689
5690       /* Initialize binding for this context. */
5691       BINDING_VALUE (b) = BINDING_VALUE (val);
5692       BINDING_TYPE (b) = BINDING_TYPE (val);
5693
5694       /* Add all _DECLs seen through local using-directives. */
5695       for (level = current_binding_level;
5696            !level->namespace_p;
5697            level = level->level_chain)
5698         if (!lookup_using_namespace (name, b, level->using_directives,
5699                                      scope, flags, spacesp))
5700           /* Give up because of error. */
5701           return error_mark_node;
5702
5703       /* Add all _DECLs seen through global using-directives. */
5704       /* XXX local and global using lists should work equally. */
5705       siter = initial;
5706       while (1)
5707         {
5708           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5709                                        scope, flags, spacesp))
5710             /* Give up because of error. */
5711             return error_mark_node;
5712           if (siter == scope) break;
5713           siter = CP_DECL_CONTEXT (siter);
5714         }
5715
5716       val = select_decl (b, flags);
5717       if (scope == global_namespace)
5718         break;
5719     }
5720   return val;
5721 }
5722
5723 /* Combine prefer_type and namespaces_only into flags.  */
5724
5725 static int
5726 lookup_flags (prefer_type, namespaces_only)
5727   int prefer_type, namespaces_only;
5728 {
5729   if (namespaces_only)
5730     return LOOKUP_PREFER_NAMESPACES;
5731   if (prefer_type > 1)
5732     return LOOKUP_PREFER_TYPES;
5733   if (prefer_type > 0)
5734     return LOOKUP_PREFER_BOTH;
5735   return 0;
5736 }
5737
5738 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5739    ignore it or not.  Subroutine of lookup_name_real.  */
5740
5741 static tree
5742 qualify_lookup (val, flags)
5743      tree val;
5744      int flags;
5745 {
5746   if (val == NULL_TREE)
5747     return val;
5748   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5749     return val;
5750   if ((flags & LOOKUP_PREFER_TYPES)
5751       && (TREE_CODE (val) == TYPE_DECL
5752           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5753               && DECL_CLASS_TEMPLATE_P (val))))
5754     return val;
5755   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5756     return NULL_TREE;
5757   return val;
5758 }
5759
5760 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5761    that.  */
5762
5763 static void
5764 warn_about_implicit_typename_lookup (typename, binding)
5765      tree typename;
5766      tree binding;
5767 {
5768   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5769   tree name = DECL_NAME (typename);
5770
5771   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5772          && CLASSTYPE_TEMPLATE_INFO (subtype)
5773          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5774       && ! (TREE_CODE (binding) == TYPE_DECL
5775             && same_type_p (TREE_TYPE (binding), subtype)))
5776     {
5777       cp_warning ("lookup of `%D' finds `%#D'",
5778                   name, binding);
5779       cp_warning ("  instead of `%D' from dependent base class",
5780                   typename);
5781       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5782                   constructor_name (current_class_type), name);
5783     }
5784 }
5785
5786 /* Look up NAME in the current binding level and its superiors in the
5787    namespace of variables, functions and typedefs.  Return a ..._DECL
5788    node of some kind representing its definition if there is only one
5789    such declaration, or return a TREE_LIST with all the overloaded
5790    definitions if there are many, or return 0 if it is undefined.
5791
5792    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5793    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5794    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5795    Otherwise we prefer non-TYPE_DECLs.
5796
5797    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5798    using IDENTIFIER_CLASS_VALUE.  */
5799
5800 static tree
5801 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5802      tree name;
5803      int prefer_type, nonclass, namespaces_only;
5804 {
5805   tree t;
5806   tree val = NULL_TREE;
5807   int yylex = 0;
5808   tree from_obj = NULL_TREE;
5809   int flags;
5810   int val_is_implicit_typename = 0;
5811
5812   /* Hack: copy flag set by parser, if set. */
5813   if (only_namespace_names)
5814     namespaces_only = 1;
5815
5816   if (prefer_type == -2)
5817     {
5818       extern int looking_for_typename;
5819       tree type = NULL_TREE;
5820
5821       yylex = 1;
5822       prefer_type = looking_for_typename;
5823
5824       flags = lookup_flags (prefer_type, namespaces_only);
5825       /* If the next thing is '<', class templates are types. */
5826       if (looking_for_template)
5827         flags |= LOOKUP_TEMPLATES_EXPECTED;
5828
5829       /* std:: becomes :: for now.  */
5830       if (got_scope == std_node)
5831         got_scope = void_type_node;
5832
5833       if (got_scope)
5834         type = got_scope;
5835       else if (got_object != error_mark_node)
5836         type = got_object;
5837
5838       if (type)
5839         {
5840           if (type == error_mark_node)
5841             return error_mark_node;
5842           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5843             type = TREE_TYPE (type);
5844
5845           if (TYPE_P (type))
5846             type = complete_type (type);
5847
5848           if (TREE_CODE (type) == VOID_TYPE)
5849             type = global_namespace;
5850           if (TREE_CODE (type) == NAMESPACE_DECL)
5851             {
5852               val = make_node (CPLUS_BINDING);
5853               flags |= LOOKUP_COMPLAIN;
5854               if (!qualified_lookup_using_namespace (name, type, val, flags))
5855                 return NULL_TREE;
5856               val = select_decl (val, flags);
5857             }
5858           else if (! IS_AGGR_TYPE (type)
5859                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5860                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5861                    || TREE_CODE (type) == TYPENAME_TYPE)
5862             /* Someone else will give an error about this if needed.  */
5863             val = NULL_TREE;
5864           else if (type == current_class_type)
5865             val = IDENTIFIER_CLASS_VALUE (name);
5866           else
5867             {
5868               val = lookup_member (type, name, 0, prefer_type);
5869               type_access_control (type, val);
5870             }
5871         }
5872       else
5873         val = NULL_TREE;
5874
5875       if (got_scope)
5876         goto done;
5877       else if (got_object && val)
5878         from_obj = val;
5879     }
5880   else
5881     {
5882       flags = lookup_flags (prefer_type, namespaces_only);
5883       /* If we're not parsing, we need to complain. */
5884       flags |= LOOKUP_COMPLAIN;
5885     }
5886
5887   /* First, look in non-namespace scopes.  */
5888
5889   if (current_class_type == NULL_TREE)
5890     nonclass = 1;
5891
5892   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5893     {
5894       tree binding;
5895
5896       if (!LOCAL_BINDING_P (t) && nonclass)
5897         /* We're not looking for class-scoped bindings, so keep going.  */
5898         continue;
5899
5900       /* If this is the kind of thing we're looking for, we're done.  */
5901       if (qualify_lookup (BINDING_VALUE (t), flags))
5902         binding = BINDING_VALUE (t);
5903       else if ((flags & LOOKUP_PREFER_TYPES)
5904                && qualify_lookup (BINDING_TYPE (t), flags))
5905         binding = BINDING_TYPE (t);
5906       else
5907         binding = NULL_TREE;
5908
5909       /* Handle access control on types from enclosing or base classes.  */
5910       if (binding && ! yylex
5911           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5912         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5913
5914       if (binding
5915           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5916         {
5917           if (val_is_implicit_typename && !yylex)
5918             warn_about_implicit_typename_lookup (val, binding);
5919           val = binding;
5920           val_is_implicit_typename
5921             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5922           if (!val_is_implicit_typename)
5923             break;
5924         }
5925     }
5926
5927   /* Now lookup in namespace scopes.  */
5928   if (!val || val_is_implicit_typename)
5929     {
5930       t = unqualified_namespace_lookup (name, flags, 0);
5931       if (t)
5932         {
5933           if (val_is_implicit_typename && !yylex)
5934             warn_about_implicit_typename_lookup (val, t);
5935           val = t;
5936         }
5937     }
5938
5939  done:
5940   if (val)
5941     {
5942       /* This should only warn about types used in qualified-ids.  */
5943       if (from_obj && from_obj != val)
5944         {
5945           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5946               && TREE_CODE (val) == TYPE_DECL
5947               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5948             {
5949               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5950                           name, got_object, TREE_TYPE (from_obj));
5951               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5952                           TREE_TYPE (val));
5953             }
5954
5955           /* We don't change val to from_obj if got_object depends on
5956              template parms because that breaks implicit typename for
5957              destructor calls.  */
5958           if (! uses_template_parms (got_object))
5959             val = from_obj;
5960         }
5961
5962       /* If we have a single function from a using decl, pull it out.  */
5963       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5964         val = OVL_FUNCTION (val);
5965     }
5966   else if (from_obj)
5967     val = from_obj;
5968
5969   return val;
5970 }
5971
5972 tree
5973 lookup_name_nonclass (name)
5974      tree name;
5975 {
5976   return lookup_name_real (name, 0, 1, 0);
5977 }
5978
5979 tree
5980 lookup_function_nonclass (name, args)
5981      tree name;
5982      tree args;
5983 {
5984   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5985 }
5986
5987 tree
5988 lookup_name_namespace_only (name)
5989      tree name;
5990 {
5991   /* type-or-namespace, nonclass, namespace_only */
5992   return lookup_name_real (name, 1, 1, 1);
5993 }
5994
5995 tree
5996 lookup_name (name, prefer_type)
5997      tree name;
5998      int prefer_type;
5999 {
6000   return lookup_name_real (name, prefer_type, 0, 0);
6001 }
6002
6003 /* Similar to `lookup_name' but look only in the innermost non-class
6004    binding level.  */
6005
6006 tree
6007 lookup_name_current_level (name)
6008      tree name;
6009 {
6010   struct binding_level *b;
6011   tree t = NULL_TREE;
6012
6013   b = current_binding_level;
6014   while (b->parm_flag == 2)
6015     b = b->level_chain;
6016
6017   if (b->namespace_p)
6018     {
6019       t = IDENTIFIER_NAMESPACE_VALUE (name);
6020
6021       /* extern "C" function() */
6022       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6023         t = TREE_VALUE (t);
6024     }
6025   else if (IDENTIFIER_BINDING (name)
6026            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6027     {
6028       while (1)
6029         {
6030           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6031             return IDENTIFIER_VALUE (name);
6032
6033           if (b->keep == 2)
6034             b = b->level_chain;
6035           else
6036             break;
6037         }
6038     }
6039
6040   return t;
6041 }
6042
6043 /* Like lookup_name_current_level, but for types.  */
6044
6045 tree
6046 lookup_type_current_level (name)
6047      tree name;
6048 {
6049   register tree t = NULL_TREE;
6050
6051   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6052
6053   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6054       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6055     {
6056       struct binding_level *b = current_binding_level;
6057       while (1)
6058         {
6059           if (purpose_member (name, b->type_shadowed))
6060             return REAL_IDENTIFIER_TYPE_VALUE (name);
6061           if (b->keep == 2)
6062             b = b->level_chain;
6063           else
6064             break;
6065         }
6066     }
6067
6068   return t;
6069 }
6070
6071 void
6072 begin_only_namespace_names ()
6073 {
6074   only_namespace_names = 1;
6075 }
6076
6077 void
6078 end_only_namespace_names ()
6079 {
6080   only_namespace_names = 0;
6081 }
6082 \f
6083 /* Arrange for the user to get a source line number, even when the
6084    compiler is going down in flames, so that she at least has a
6085    chance of working around problems in the compiler.  We used to
6086    call error(), but that let the segmentation fault continue
6087    through; now, it's much more passive by asking them to send the
6088    maintainers mail about the problem.  */
6089
6090 static void
6091 signal_catch (sig)
6092      int sig ATTRIBUTE_UNUSED;
6093 {
6094   signal (SIGSEGV, SIG_DFL);
6095 #ifdef SIGIOT
6096   signal (SIGIOT, SIG_DFL);
6097 #endif
6098 #ifdef SIGILL
6099   signal (SIGILL, SIG_DFL);
6100 #endif
6101 #ifdef SIGABRT
6102   signal (SIGABRT, SIG_DFL);
6103 #endif
6104 #ifdef SIGBUS
6105   signal (SIGBUS, SIG_DFL);
6106 #endif
6107   my_friendly_abort (0);
6108 }
6109
6110 /* Push the declarations of builtin types into the namespace.
6111    RID_INDEX, if < RID_MAX is the index of the builtin type
6112    in the array RID_POINTERS.  NAME is the name used when looking
6113    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6114
6115 static void
6116 record_builtin_type (rid_index, name, type)
6117      enum rid rid_index;
6118      const char *name;
6119      tree type;
6120 {
6121   tree rname = NULL_TREE, tname = NULL_TREE;
6122   tree tdecl = NULL_TREE;
6123
6124   if ((int) rid_index < (int) RID_MAX)
6125     rname = ridpointers[(int) rid_index];
6126   if (name)
6127     tname = get_identifier (name);
6128
6129   TYPE_BUILT_IN (type) = 1;
6130
6131   if (tname)
6132     {
6133       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6134       set_identifier_type_value (tname, NULL_TREE);
6135       if ((int) rid_index < (int) RID_MAX)
6136         /* Built-in types live in the global namespace. */
6137         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6138     }
6139   if (rname != NULL_TREE)
6140     {
6141       if (tname != NULL_TREE)
6142         {
6143           set_identifier_type_value (rname, NULL_TREE);
6144           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6145         }
6146       else
6147         {
6148           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6149           set_identifier_type_value (rname, NULL_TREE);
6150         }
6151     }
6152 }
6153
6154 /* Record one of the standard Java types.
6155  * Declare it as having the given NAME.
6156  * If SIZE > 0, it is the size of one of the integral types;
6157  * otherwise it is the negative of the size of one of the other types.  */
6158
6159 static tree
6160 record_builtin_java_type (name, size)
6161      const char *name;
6162      int size;
6163 {
6164   tree type, decl;
6165   if (size > 0)
6166     type = make_signed_type (size);
6167   else if (size > -32)
6168     { /* "__java_char" or ""__java_boolean". */
6169       type = make_unsigned_type (-size);
6170       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6171     }
6172   else
6173     { /* "__java_float" or ""__java_double". */
6174       type = make_node (REAL_TYPE);
6175       TYPE_PRECISION (type) = - size;
6176       layout_type (type);
6177     }
6178   record_builtin_type (RID_MAX, name, type);
6179   decl = TYPE_NAME (type);
6180
6181   /* Suppress generate debug symbol entries for these types,
6182      since for normal C++ they are just clutter.
6183      However, push_lang_context undoes this if extern "Java" is seen. */
6184   DECL_IGNORED_P (decl) = 1;
6185
6186   TYPE_FOR_JAVA (type) = 1;
6187   return type;
6188 }
6189
6190 /* Push a type into the namespace so that the back-ends ignore it. */
6191
6192 static void
6193 record_unknown_type (type, name)
6194      tree type;
6195      const char *name;
6196 {
6197   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6198   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6199   DECL_IGNORED_P (decl) = 1;
6200   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6201   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6202   TYPE_ALIGN (type) = 1;
6203   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6204 }
6205
6206 /* An string for which we should create an IDENTIFIER_NODE at
6207    startup.  */
6208
6209 typedef struct predefined_identifier
6210 {
6211   /* The name of the identifier.  */
6212   const char *name;
6213   /* The place where the IDENTIFIER_NODE should be stored.  */
6214   tree *node;
6215   /* Non-zero if this is the name of a constructor or destructor.  */
6216   int ctor_or_dtor_p;
6217 } predefined_identifier;
6218
6219 /* Create all the predefined identifiers.  */
6220
6221 static void
6222 initialize_predefined_identifiers ()
6223 {
6224   struct predefined_identifier *pid;
6225
6226   /* A table of identifiers to create at startup.  */
6227   static predefined_identifier predefined_identifiers[] = {
6228     { "C++", &lang_name_cplusplus, 0 },
6229     { "C", &lang_name_c, 0 },
6230     { "Java", &lang_name_java, 0 },
6231     { CTOR_NAME, &ctor_identifier, 1 },
6232     { "__base_ctor", &base_ctor_identifier, 1 },
6233     { "__comp_ctor", &complete_ctor_identifier, 1 },
6234     { DTOR_NAME, &dtor_identifier, 1 },
6235     { "__comp_dtor", &complete_dtor_identifier, 1 },
6236     { "__base_dtor", &base_dtor_identifier, 1 },
6237     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6238     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6239     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6240     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6241     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6242     { "nelts", &nelts_identifier, 0 },
6243     { THIS_NAME, &this_identifier, 0 },
6244     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6245     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6246     { "_vptr", &vptr_identifier, 0 },
6247     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6248     { "__vtt_parm", &vtt_parm_identifier, 0 },
6249     { "std", &std_identifier, 0 },
6250     { NULL, NULL, 0 }
6251   };
6252
6253   for (pid = predefined_identifiers; pid->name; ++pid)
6254     {
6255       *pid->node = get_identifier (pid->name);
6256       if (pid->ctor_or_dtor_p)
6257         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6258     }
6259 }
6260
6261 /* Create the predefined scalar types of C,
6262    and some nodes representing standard constants (0, 1, (void *)0).
6263    Initialize the global binding level.
6264    Make definitions for built-in primitive functions.  */
6265
6266 void
6267 init_decl_processing ()
6268 {
6269   tree fields[20];
6270   int wchar_type_size;
6271   tree array_domain_type;
6272
6273   /* Check to see that the user did not specify an invalid combination
6274      of command-line options.  */
6275   if (flag_new_abi && !flag_vtable_thunks)
6276     fatal ("the new ABI requires vtable thunks");
6277
6278   /* Create all the identifiers we need.  */
6279   initialize_predefined_identifiers ();
6280
6281   /* Let the back-end now how to save and restore language-specific
6282      per-function globals.  */
6283   init_lang_status = &push_cp_function_context;
6284   free_lang_status = &pop_cp_function_context;
6285   mark_lang_status = &mark_cp_function_context;
6286
6287   cp_parse_init ();
6288   init_decl2 ();
6289   init_pt ();
6290
6291   /* Create the global variables.  */
6292   push_to_top_level ();
6293
6294   /* Enter the global namespace. */
6295   my_friendly_assert (global_namespace == NULL_TREE, 375);
6296   push_namespace (get_identifier ("::"));
6297   global_namespace = current_namespace;
6298   current_lang_name = NULL_TREE;
6299
6300   /* Adjust various flags based on command-line settings.  */
6301   if (flag_strict_prototype == 2)
6302     flag_strict_prototype = pedantic;
6303   if (! flag_permissive && ! pedantic)
6304     flag_pedantic_errors = 1;
6305   if (!flag_no_inline)
6306     flag_inline_trees = 1;
6307
6308   strict_prototypes_lang_c = flag_strict_prototype;
6309
6310   /* Initially, C.  */
6311   current_lang_name = lang_name_c;
6312
6313   current_function_decl = NULL_TREE;
6314   current_binding_level = NULL_BINDING_LEVEL;
6315   free_binding_level = NULL_BINDING_LEVEL;
6316
6317   /* Because most segmentation signals can be traced back into user
6318      code, catch them and at least give the user a chance of working
6319      around compiler bugs.  */
6320   signal (SIGSEGV, signal_catch);
6321
6322   /* We will also catch aborts in the back-end through signal_catch and
6323      give the user a chance to see where the error might be, and to defeat
6324      aborts in the back-end when there have been errors previously in their
6325      code.  */
6326 #ifdef SIGIOT
6327   signal (SIGIOT, signal_catch);
6328 #endif
6329 #ifdef SIGILL
6330   signal (SIGILL, signal_catch);
6331 #endif
6332 #ifdef SIGABRT
6333   signal (SIGABRT, signal_catch);
6334 #endif
6335 #ifdef SIGBUS
6336   signal (SIGBUS, signal_catch);
6337 #endif
6338
6339   build_common_tree_nodes (flag_signed_char);
6340
6341   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6342   TREE_TYPE (error_mark_list) = error_mark_node;
6343
6344   /* Make the binding_level structure for global names.  */
6345   pushlevel (0);
6346   global_binding_level = current_binding_level;
6347   /* The global level is the namespace level of ::.  */
6348   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6349   declare_namespace_level ();
6350
6351   /* Define `int' and `char' first so that dbx will output them first.  */
6352   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6353   record_builtin_type (RID_CHAR, "char", char_type_node);
6354
6355   /* `signed' is the same as `int' */
6356   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6357   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6358   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6359   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6360   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6361   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6362   record_builtin_type (RID_MAX, "long long unsigned int",
6363                        long_long_unsigned_type_node);
6364   record_builtin_type (RID_MAX, "long long unsigned",
6365                        long_long_unsigned_type_node);
6366   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6367   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6368   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6369
6370   ptrdiff_type_node
6371     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6372
6373   /* Define both `signed char' and `unsigned char'.  */
6374   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6375   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6376
6377   /* `unsigned long' is the standard type for sizeof.
6378      Note that stddef.h uses `unsigned long',
6379      and this must agree, even if long and int are the same size.  */
6380   set_sizetype
6381     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6382
6383   /* Create the widest literal types. */
6384   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6385   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6386                         widest_integer_literal_type_node));
6387
6388   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6389   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6390                         widest_unsigned_literal_type_node));
6391
6392   /* These are types that type_for_size and type_for_mode use.  */
6393   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6394   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6395   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6396   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6397 #if HOST_BITS_PER_WIDE_INT >= 64
6398   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6399 #endif
6400   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6401   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6402   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6403   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6404 #if HOST_BITS_PER_WIDE_INT >= 64
6405   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6406 #endif
6407
6408   build_common_tree_nodes_2 (flag_short_double);
6409
6410   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6411   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6412   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6413   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6414   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6415   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6416   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6417   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6418
6419   integer_two_node = build_int_2 (2, 0);
6420   TREE_TYPE (integer_two_node) = integer_type_node;
6421   integer_three_node = build_int_2 (3, 0);
6422   TREE_TYPE (integer_three_node) = integer_type_node;
6423
6424   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6425   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6426   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6427   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6428   TYPE_PRECISION (boolean_type_node) = 1;
6429   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6430   boolean_false_node = build_int_2 (0, 0);
6431   TREE_TYPE (boolean_false_node) = boolean_type_node;
6432   boolean_true_node = build_int_2 (1, 0);
6433   TREE_TYPE (boolean_true_node) = boolean_type_node;
6434
6435   signed_size_zero_node = build_int_2 (0, 0);
6436   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6437   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6438   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6439
6440   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6441                         complex_integer_type_node));
6442   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6443                         complex_float_type_node));
6444   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6445                         complex_double_type_node));
6446   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6447                         complex_long_double_type_node));
6448
6449   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6450
6451   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6452   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6453   TREE_PARMLIST (void_list_node) = 1;
6454
6455   /* Used for expressions that do nothing, but are not errors.  */
6456   void_zero_node = build_int_2 (0, 0);
6457   TREE_TYPE (void_zero_node) = void_type_node;
6458
6459   string_type_node = build_pointer_type (char_type_node);
6460   const_string_type_node
6461     = build_pointer_type (build_qualified_type (char_type_node,
6462                                                 TYPE_QUAL_CONST));
6463   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6464 #if 0
6465   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6466 #endif
6467
6468   /* Make a type to be the domain of a few array types
6469      whose domains don't really matter.
6470      200 is small enough that it always fits in size_t.  */
6471   array_domain_type = build_index_type (build_int_2 (200, 0));
6472
6473   /* Make a type for arrays of characters.
6474      With luck nothing will ever really depend on the length of this
6475      array type.  */
6476   char_array_type_node
6477     = build_array_type (char_type_node, array_domain_type);
6478
6479   /* Likewise for arrays of ints.  */
6480   int_array_type_node
6481     = build_array_type (integer_type_node, array_domain_type);
6482
6483   if (flag_new_abi)
6484     delta_type_node = ptrdiff_type_node;
6485   else if (flag_huge_objects)
6486     delta_type_node = long_integer_type_node;
6487   else
6488     delta_type_node = short_integer_type_node;
6489
6490   if (flag_new_abi)
6491     vtable_index_type = ptrdiff_type_node;
6492   else
6493     vtable_index_type = delta_type_node;
6494
6495   default_function_type
6496     = build_function_type (integer_type_node, NULL_TREE);
6497
6498   ptr_type_node = build_pointer_type (void_type_node);
6499   const_ptr_type_node
6500     = build_pointer_type (build_qualified_type (void_type_node,
6501                                                 TYPE_QUAL_CONST));
6502   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6503   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6504   lang_type_promotes_to = convert_type_from_ellipsis;
6505
6506   void_ftype_ptr
6507     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6508
6509   /* C++ extensions */
6510
6511   unknown_type_node = make_node (UNKNOWN_TYPE);
6512   record_unknown_type (unknown_type_node, "unknown type");
6513
6514   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6515   TREE_TYPE (unknown_type_node) = unknown_type_node;
6516
6517   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6518
6519   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6520      result.  */
6521   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6522   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6523
6524   /* This is special for C++ so functions can be overloaded.  */
6525   wchar_type_node = get_identifier (flag_short_wchar
6526                                     ? "short unsigned int"
6527                                     : WCHAR_TYPE);
6528   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6529   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6530   signed_wchar_type_node = make_signed_type (wchar_type_size);
6531   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6532   wchar_type_node
6533     = TREE_UNSIGNED (wchar_type_node)
6534       ? unsigned_wchar_type_node
6535       : signed_wchar_type_node;
6536   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6537
6538   /* Artificial declaration of wchar_t -- can be bashed */
6539   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6540                                 wchar_type_node);
6541   pushdecl (wchar_decl_node);
6542
6543   /* This is for wide string constants.  */
6544   wchar_array_type_node
6545     = build_array_type (wchar_type_node, array_domain_type);
6546
6547   if (flag_vtable_thunks)
6548     {
6549       /* Make sure we get a unique function type, so we can give
6550          its pointer type a name.  (This wins for gdb.) */
6551       tree vfunc_type = make_node (FUNCTION_TYPE);
6552       TREE_TYPE (vfunc_type) = integer_type_node;
6553       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6554       layout_type (vfunc_type);
6555
6556       vtable_entry_type = build_pointer_type (vfunc_type);
6557     }
6558   else
6559     {
6560       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6561       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6562                               delta_type_node);
6563       fields[1] = build_decl (FIELD_DECL, index_identifier,
6564                               delta_type_node);
6565       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6566                               ptr_type_node);
6567       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6568                            double_type_node);
6569
6570       /* Make this part of an invisible union.  */
6571       fields[3] = copy_node (fields[2]);
6572       TREE_TYPE (fields[3]) = delta_type_node;
6573       DECL_NAME (fields[3]) = delta2_identifier;
6574       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6575       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6576       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6577       TREE_UNSIGNED (fields[3]) = 0;
6578       TREE_CHAIN (fields[2]) = fields[3];
6579       vtable_entry_type = build_qualified_type (vtable_entry_type,
6580                                                 TYPE_QUAL_CONST);
6581     }
6582   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6583
6584   vtbl_type_node
6585     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6586   layout_type (vtbl_type_node);
6587   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6588   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6589   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6590   layout_type (vtbl_ptr_type_node);
6591   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6592
6593   std_node = build_decl (NAMESPACE_DECL,
6594                          flag_honor_std
6595                          ? get_identifier ("fake std") : std_identifier,
6596                          void_type_node);
6597   pushdecl (std_node);
6598
6599   if (flag_new_abi)
6600     {
6601       push_namespace (get_identifier ("__cxxabiv1"));
6602       abi_node = current_namespace;
6603       pop_namespace ();
6604     }
6605
6606   global_type_node = make_node (LANG_TYPE);
6607   record_unknown_type (global_type_node, "global type");
6608
6609   /* Now, C++.  */
6610   current_lang_name = lang_name_cplusplus;
6611
6612   {
6613     tree bad_alloc_type_node, newtype, deltype;
6614     if (flag_honor_std)
6615       push_namespace (get_identifier ("std"));
6616     bad_alloc_type_node = xref_tag
6617       (class_type_node, get_identifier ("bad_alloc"), 1);
6618     if (flag_honor_std)
6619       pop_namespace ();
6620     newtype = build_exception_variant
6621       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6622     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6623     push_cp_library_fn (NEW_EXPR, newtype);
6624     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6625     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6626     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6627   }
6628
6629   abort_fndecl
6630     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6631
6632   /* Perform other language dependent initializations.  */
6633   init_class_processing ();
6634   init_init_processing ();
6635   init_search_processing ();
6636   init_rtti_processing ();
6637
6638   if (flag_exceptions)
6639     init_exception_processing ();
6640   if (flag_no_inline)
6641     {
6642       flag_inline_functions = 0;
6643     }
6644
6645   if (! supports_one_only ())
6646     flag_weak = 0;
6647
6648   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6649   make_fname_decl = cp_make_fname_decl;
6650   declare_function_name ();
6651
6652   /* Prepare to check format strings against argument lists.  */
6653   init_function_format_info ();
6654
6655   /* Show we use EH for cleanups.  */
6656   using_eh_for_cleanups ();
6657
6658   print_error_function = lang_print_error_function;
6659   valid_lang_attribute = cp_valid_lang_attribute;
6660
6661   /* Maintain consistency.  Perhaps we should just complain if they
6662      say -fwritable-strings?  */
6663   if (flag_writable_strings)
6664     flag_const_strings = 0;
6665
6666   /* Add GC roots for all of our global variables.  */
6667   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6668   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6669   ggc_add_tree_root (&integer_three_node, 1);
6670   ggc_add_tree_root (&integer_two_node, 1);
6671   ggc_add_tree_root (&signed_size_zero_node, 1);
6672   ggc_add_tree_root (&size_one_node, 1);
6673   ggc_add_tree_root (&size_zero_node, 1);
6674   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6675                 mark_binding_level);
6676   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6677   ggc_add_tree_root (&static_ctors, 1);
6678   ggc_add_tree_root (&static_dtors, 1);
6679   ggc_add_tree_root (&lastiddecl, 1);
6680
6681   ggc_add_tree_root (&last_function_parm_tags, 1);
6682   ggc_add_tree_root (&current_function_return_value, 1);
6683   ggc_add_tree_root (&current_function_parms, 1);
6684   ggc_add_tree_root (&current_function_parm_tags, 1);
6685   ggc_add_tree_root (&last_function_parms, 1);
6686   ggc_add_tree_root (&error_mark_list, 1);
6687
6688   ggc_add_tree_root (&global_namespace, 1);
6689   ggc_add_tree_root (&global_type_node, 1);
6690   ggc_add_tree_root (&anonymous_namespace_name, 1);
6691
6692   ggc_add_tree_root (&got_object, 1);
6693   ggc_add_tree_root (&got_scope, 1);
6694
6695   ggc_add_tree_root (&current_lang_name, 1);
6696   ggc_add_tree_root (&static_aggregates, 1);
6697 }
6698
6699 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6700    decl, NAME is the initialization string and TYPE_DEP indicates whether
6701    NAME depended on the type of the function. We make use of that to detect
6702    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6703    the function before emitting any of it, we don't need to treat the
6704    VAR_DECL specially. We can decide whether to emit it later, if it was
6705    used.  */
6706
6707 static tree
6708 cp_make_fname_decl (id, name, type_dep)
6709      tree id;
6710      const char *name;
6711      int type_dep;
6712 {
6713   tree decl, type, init;
6714   size_t length = strlen (name);
6715   tree domain = NULL_TREE;
6716
6717   if (!processing_template_decl)
6718     type_dep = 0;
6719   if (!type_dep)
6720     domain = build_index_type (build_int_2 (length, 0));
6721
6722   type =  build_cplus_array_type
6723           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6724            domain);
6725
6726   decl = build_decl (VAR_DECL, id, type);
6727   TREE_STATIC (decl) = 1;
6728   TREE_READONLY (decl) = 1;
6729   DECL_SOURCE_LINE (decl) = 0;
6730   DECL_ARTIFICIAL (decl) = 1;
6731   DECL_IN_SYSTEM_HEADER (decl) = 1;
6732   pushdecl (decl);
6733   if (processing_template_decl)
6734     decl = push_template_decl (decl);
6735   if (type_dep)
6736     {
6737       init = build (FUNCTION_NAME, type);
6738       DECL_PRETTY_FUNCTION_P (decl) = 1;
6739     }
6740   else
6741     {
6742       init = build_string (length + 1, name);
6743       TREE_TYPE (init) = type;
6744     }
6745   DECL_INITIAL (decl) = init;
6746   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6747
6748   /* We will have to make sure we only emit this, if it is actually used. */
6749   return decl;
6750 }
6751
6752 /* Function to print any language-specific context for an error message.  */
6753
6754 static void
6755 lang_print_error_function (file)
6756      const char *file;
6757 {
6758   default_print_error_function (file);
6759   maybe_print_template_context ();
6760 }
6761
6762 /* Entry point for the benefit of c_common_nodes_and_builtins.
6763
6764    Make a definition for a builtin function named NAME and whose data type
6765    is TYPE.  TYPE should be a function type with argument types.
6766
6767    CLASS and CODE tell later passes how to compile calls to this function.
6768    See tree.h for possible values.
6769
6770    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6771    the name to be called if we can't opencode the function.  */
6772
6773 tree
6774 builtin_function (name, type, code, class, libname)
6775      const char *name;
6776      tree type;
6777      int code;
6778      enum built_in_class class;
6779      const char *libname;
6780 {
6781   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6782   DECL_BUILT_IN_CLASS (decl) = class;
6783   DECL_FUNCTION_CODE (decl) = code;
6784
6785   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6786
6787   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6788      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6789      function in the namespace.  */
6790   pushdecl (decl);
6791   if (libname)
6792     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6793   make_function_rtl (decl);
6794
6795   /* Warn if a function in the namespace for users
6796      is used without an occasion to consider it declared.  */
6797   if (name[0] != '_' || name[1] != '_')
6798     DECL_ANTICIPATED (decl) = 1;
6799
6800   return decl;
6801 }
6802
6803 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6804    function.  Not called directly.  */
6805
6806 static tree
6807 build_library_fn_1 (name, operator_code, type)
6808      tree name;
6809      enum tree_code operator_code;
6810      tree type;
6811 {
6812   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6813   DECL_EXTERNAL (fn) = 1;
6814   TREE_PUBLIC (fn) = 1;
6815   DECL_ARTIFICIAL (fn) = 1;
6816   TREE_NOTHROW (fn) = 1;
6817   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6818   return fn;
6819 }
6820
6821 /* Returns the _DECL for a library function with C linkage.
6822    We assume that such functions never throw; if this is incorrect,
6823    callers should unset TREE_NOTHROW.  */
6824
6825 tree
6826 build_library_fn (name, type)
6827      tree name;
6828      tree type;
6829 {
6830   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6831   make_function_rtl (fn);
6832   return fn;
6833 }
6834
6835 /* Returns the _DECL for a library function with C++ linkage.  */
6836
6837 static tree
6838 build_cp_library_fn (name, operator_code, type)
6839      tree name;
6840      enum tree_code operator_code;
6841      tree type;
6842 {
6843   tree fn = build_library_fn_1 (name, operator_code, type);
6844   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6845   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6846   set_mangled_name_for_decl (fn);
6847   make_function_rtl (fn);
6848   return fn;
6849 }
6850
6851 /* Like build_library_fn, but takes a C string instead of an
6852    IDENTIFIER_NODE.  */
6853
6854 tree
6855 build_library_fn_ptr (name, type)
6856      const char *name;
6857      tree type;
6858 {
6859   return build_library_fn (get_identifier (name), type);
6860 }
6861
6862 /* Like build_cp_library_fn, but takes a C string instead of an
6863    IDENTIFIER_NODE.  */
6864
6865 tree
6866 build_cp_library_fn_ptr (name, type)
6867      const char *name;
6868      tree type;
6869 {
6870   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6871 }
6872
6873 /* Like build_library_fn, but also pushes the function so that we will
6874    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6875
6876 tree
6877 push_library_fn (name, type)
6878      tree name, type;
6879 {
6880   tree fn = build_library_fn (name, type);
6881   pushdecl_top_level (fn);
6882   return fn;
6883 }
6884
6885 /* Like build_cp_library_fn, but also pushes the function so that it
6886    will be found by normal lookup.  */
6887
6888 static tree
6889 push_cp_library_fn (operator_code, type)
6890      enum tree_code operator_code;
6891      tree type;
6892 {
6893   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6894                                  operator_code,
6895                                  type);
6896   pushdecl (fn);
6897   return fn;
6898 }
6899
6900 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6901    a FUNCTION_TYPE.  */
6902
6903 tree
6904 push_void_library_fn (name, parmtypes)
6905      tree name, parmtypes;
6906 {
6907   tree type = build_function_type (void_type_node, parmtypes);
6908   return push_library_fn (name, type);
6909 }
6910
6911 /* Like push_library_fn, but also note that this function throws
6912    and does not return.  Used for __throw_foo and the like.  */
6913
6914 tree
6915 push_throw_library_fn (name, type)
6916      tree name, type;
6917 {
6918   tree fn = push_library_fn (name, type);
6919   TREE_THIS_VOLATILE (fn) = 1;
6920   TREE_NOTHROW (fn) = 0;
6921   return fn;
6922 }
6923 \f
6924 /* When we call finish_struct for an anonymous union, we create
6925    default copy constructors and such.  But, an anonymous union
6926    shouldn't have such things; this function undoes the damage to the
6927    anonymous union type T.
6928
6929    (The reason that we create the synthesized methods is that we don't
6930    distinguish `union { int i; }' from `typedef union { int i; } U'.
6931    The first is an anonymous union; the second is just an ordinary
6932    union type.)  */
6933
6934 void
6935 fixup_anonymous_aggr (t)
6936      tree t;
6937 {
6938   tree *q;
6939
6940   /* Wipe out memory of synthesized methods */
6941   TYPE_HAS_CONSTRUCTOR (t) = 0;
6942   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6943   TYPE_HAS_INIT_REF (t) = 0;
6944   TYPE_HAS_CONST_INIT_REF (t) = 0;
6945   TYPE_HAS_ASSIGN_REF (t) = 0;
6946   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6947
6948   /* Splice the implicitly generated functions out of the TYPE_METHODS
6949      list.  */
6950   q = &TYPE_METHODS (t);
6951   while (*q)
6952     {
6953       if (DECL_ARTIFICIAL (*q))
6954         *q = TREE_CHAIN (*q);
6955       else
6956         q = &TREE_CHAIN (*q);
6957     }
6958
6959   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6960   if (TYPE_METHODS (t))
6961     error ("an anonymous union cannot have function members");
6962 }
6963
6964 /* Make sure that a declaration with no declarator is well-formed, i.e.
6965    just defines a tagged type or anonymous union.
6966
6967    Returns the type defined, if any.  */
6968
6969 tree
6970 check_tag_decl (declspecs)
6971      tree declspecs;
6972 {
6973   int found_type = 0;
6974   int saw_friend = 0;
6975   tree ob_modifier = NULL_TREE;
6976   register tree link;
6977   register tree t = NULL_TREE;
6978
6979   for (link = declspecs; link; link = TREE_CHAIN (link))
6980     {
6981       register tree value = TREE_VALUE (link);
6982
6983       if (TYPE_P (value)
6984           || (TREE_CODE (value) == IDENTIFIER_NODE
6985               && IDENTIFIER_GLOBAL_VALUE (value)
6986               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6987         {
6988           ++found_type;
6989
6990           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6991             {
6992               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6993               t = value;
6994             }
6995         }
6996       else if (value == ridpointers[(int) RID_FRIEND])
6997         {
6998           if (current_class_type == NULL_TREE
6999               || current_scope () != current_class_type)
7000             ob_modifier = value;
7001           else
7002             saw_friend = 1;
7003         }
7004       else if (value == ridpointers[(int) RID_STATIC]
7005                || value == ridpointers[(int) RID_EXTERN]
7006                || value == ridpointers[(int) RID_AUTO]
7007                || value == ridpointers[(int) RID_REGISTER]
7008                || value == ridpointers[(int) RID_INLINE]
7009                || value == ridpointers[(int) RID_VIRTUAL]
7010                || value == ridpointers[(int) RID_CONST]
7011                || value == ridpointers[(int) RID_VOLATILE]
7012                || value == ridpointers[(int) RID_EXPLICIT])
7013         ob_modifier = value;
7014     }
7015
7016   if (found_type > 1)
7017     error ("multiple types in one declaration");
7018
7019   if (t == NULL_TREE && ! saw_friend)
7020     pedwarn ("declaration does not declare anything");
7021
7022   /* Check for an anonymous union.  We're careful
7023      accessing TYPE_IDENTIFIER because some built-in types, like
7024      pointer-to-member types, do not have TYPE_NAME.  */
7025   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7026            && TYPE_NAME (t)
7027            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7028     {
7029       /* Anonymous unions are objects, so they can have specifiers.  */;
7030       SET_ANON_AGGR_TYPE_P (t);
7031
7032       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7033         pedwarn ("ISO C++ prohibits anonymous structs");
7034     }
7035
7036   else if (ob_modifier)
7037     {
7038       if (ob_modifier == ridpointers[(int) RID_INLINE]
7039           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7040         cp_error ("`%D' can only be specified for functions", ob_modifier);
7041       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7042         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7043       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7044         cp_error ("`%D' can only be specified for constructors",
7045                   ob_modifier);
7046       else
7047         cp_error ("`%D' can only be specified for objects and functions",
7048                   ob_modifier);
7049     }
7050
7051   return t;
7052 }
7053
7054 /* Called when a declaration is seen that contains no names to declare.
7055    If its type is a reference to a structure, union or enum inherited
7056    from a containing scope, shadow that tag name for the current scope
7057    with a forward reference.
7058    If its type defines a new named structure or union
7059    or defines an enum, it is valid but we need not do anything here.
7060    Otherwise, it is an error.
7061
7062    C++: may have to grok the declspecs to learn about static,
7063    complain for anonymous unions.  */
7064
7065 void
7066 shadow_tag (declspecs)
7067      tree declspecs;
7068 {
7069   tree t = check_tag_decl (declspecs);
7070
7071   if (t)
7072     maybe_process_partial_specialization (t);
7073
7074   /* This is where the variables in an anonymous union are
7075      declared.  An anonymous union declaration looks like:
7076      union { ... } ;
7077      because there is no declarator after the union, the parser
7078      sends that declaration here.  */
7079   if (t && ANON_AGGR_TYPE_P (t))
7080     {
7081       fixup_anonymous_aggr (t);
7082
7083       if (TYPE_FIELDS (t))
7084         {
7085           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7086                                       NULL_TREE);
7087           finish_anon_union (decl);
7088         }
7089     }
7090 }
7091 \f
7092 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7093
7094 tree
7095 groktypename (typename)
7096      tree typename;
7097 {
7098   if (TREE_CODE (typename) != TREE_LIST)
7099     return typename;
7100   return grokdeclarator (TREE_VALUE (typename),
7101                          TREE_PURPOSE (typename),
7102                          TYPENAME, 0, NULL_TREE);
7103 }
7104
7105 /* Decode a declarator in an ordinary declaration or data definition.
7106    This is called as soon as the type information and variable name
7107    have been parsed, before parsing the initializer if any.
7108    Here we create the ..._DECL node, fill in its type,
7109    and put it on the list of decls for the current context.
7110    The ..._DECL node is returned as the value.
7111
7112    Exception: for arrays where the length is not specified,
7113    the type is left null, to be filled in by `cp_finish_decl'.
7114
7115    Function definitions do not come here; they go to start_function
7116    instead.  However, external and forward declarations of functions
7117    do go through here.  Structure field declarations are done by
7118    grokfield and not through here.  */
7119
7120 tree
7121 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7122      tree declarator, declspecs;
7123      int initialized;
7124      tree attributes, prefix_attributes;
7125 {
7126   register tree decl;
7127   register tree type, tem;
7128   tree context;
7129   extern int have_extern_spec;
7130   extern int used_extern_spec;
7131   tree attrlist;
7132
7133 #if 0
7134   /* See code below that used this.  */
7135   int init_written = initialized;
7136 #endif
7137
7138   /* This should only be done once on the top most decl.  */
7139   if (have_extern_spec && !used_extern_spec)
7140     {
7141       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7142                                   declspecs);
7143       used_extern_spec = 1;
7144     }
7145
7146   if (attributes || prefix_attributes)
7147     attrlist = build_tree_list (attributes, prefix_attributes);
7148   else
7149     attrlist = NULL_TREE;
7150
7151   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7152                          attrlist);
7153
7154   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7155     return NULL_TREE;
7156
7157   type = TREE_TYPE (decl);
7158
7159   if (type == error_mark_node)
7160     return NULL_TREE;
7161
7162   context = DECL_CONTEXT (decl);
7163
7164   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7165       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7166     {
7167       /* When parsing the initializer, lookup should use the object's
7168          namespace. */
7169       push_decl_namespace (context);
7170     }
7171
7172   /* We are only interested in class contexts, later. */
7173   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7174     context = NULL_TREE;
7175
7176   if (initialized)
7177     /* Is it valid for this decl to have an initializer at all?
7178        If not, set INITIALIZED to zero, which will indirectly
7179        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7180     switch (TREE_CODE (decl))
7181       {
7182       case TYPE_DECL:
7183         /* typedef foo = bar  means give foo the same type as bar.
7184            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7185            Any other case of an initialization in a TYPE_DECL is an error.  */
7186         if (pedantic || list_length (declspecs) > 1)
7187           {
7188             cp_error ("typedef `%D' is initialized", decl);
7189             initialized = 0;
7190           }
7191         break;
7192
7193       case FUNCTION_DECL:
7194         cp_error ("function `%#D' is initialized like a variable", decl);
7195         initialized = 0;
7196         break;
7197
7198       default:
7199         break;
7200       }
7201
7202   if (initialized)
7203     {
7204       if (! toplevel_bindings_p ()
7205           && DECL_EXTERNAL (decl))
7206         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7207                     decl);
7208       DECL_EXTERNAL (decl) = 0;
7209       if (toplevel_bindings_p ())
7210         TREE_STATIC (decl) = 1;
7211
7212       /* Tell `pushdecl' this is an initialized decl
7213          even though we don't yet have the initializer expression.
7214          Also tell `cp_finish_decl' it may store the real initializer.  */
7215       DECL_INITIAL (decl) = error_mark_node;
7216     }
7217
7218 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7219   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7220 #endif
7221
7222   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7223   cplus_decl_attributes (decl, attributes, prefix_attributes);
7224
7225   if (context && COMPLETE_TYPE_P (complete_type (context)))
7226     {
7227       push_nested_class (context, 2);
7228
7229       if (TREE_CODE (decl) == VAR_DECL)
7230         {
7231           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7232           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7233             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7234           else
7235             {
7236               if (DECL_CONTEXT (field) != context)
7237                 {
7238                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7239                               DECL_CONTEXT (field), DECL_NAME (decl),
7240                               context, DECL_NAME (decl));
7241                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7242                 }
7243               /* Static data member are tricky; an in-class initialization
7244                  still doesn't provide a definition, so the in-class
7245                  declaration will have DECL_EXTERNAL set, but will have an
7246                  initialization.  Thus, duplicate_decls won't warn
7247                  about this situation, and so we check here.  */
7248               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7249                 cp_error ("duplicate initialization of %D", decl);
7250               if (duplicate_decls (decl, field))
7251                 decl = field;
7252             }
7253         }
7254       else
7255         {
7256           tree field = check_classfn (context, decl);
7257           if (field && duplicate_decls (decl, field))
7258             decl = field;
7259         }
7260
7261       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7262       DECL_IN_AGGR_P (decl) = 0;
7263       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7264           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7265         {
7266           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7267           /* [temp.expl.spec] An explicit specialization of a static data
7268              member of a template is a definition if the declaration
7269              includes an initializer; otherwise, it is a declaration.
7270
7271              We check for processing_specialization so this only applies
7272              to the new specialization syntax.  */
7273           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7274             DECL_EXTERNAL (decl) = 1;
7275         }
7276
7277       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7278         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7279                     decl);
7280     }
7281
7282   /* Enter this declaration into the symbol table.  */
7283   tem = maybe_push_decl (decl);
7284
7285   if (processing_template_decl)
7286     tem = push_template_decl (tem);
7287
7288 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7289   /* Tell the back-end to use or not use .common as appropriate.  If we say
7290      -fconserve-space, we want this to save .data space, at the expense of
7291      wrong semantics.  If we say -fno-conserve-space, we want this to
7292      produce errors about redefs; to do this we force variables into the
7293      data segment.  */
7294   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7295 #endif
7296
7297   if (! processing_template_decl)
7298     start_decl_1 (tem);
7299
7300   return tem;
7301 }
7302
7303 void
7304 start_decl_1 (decl)
7305      tree decl;
7306 {
7307   tree type = TREE_TYPE (decl);
7308   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7309
7310   if (type == error_mark_node)
7311     return;
7312
7313   /* If this type of object needs a cleanup, but we're not allowed to
7314      add any more objects with cleanups to the current scope, create a
7315      new binding level.  */
7316   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7317       && current_binding_level->more_cleanups_ok == 0)
7318     {
7319       keep_next_level (2);
7320       pushlevel (1);
7321       clear_last_expr ();
7322       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7323     }
7324
7325   if (initialized)
7326     /* Is it valid for this decl to have an initializer at all?
7327        If not, set INITIALIZED to zero, which will indirectly
7328        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7329     {
7330       /* Don't allow initializations for incomplete types except for
7331          arrays which might be completed by the initialization.  */
7332       if (COMPLETE_TYPE_P (complete_type (type)))
7333         ;                       /* A complete type is ok.  */
7334       else if (TREE_CODE (type) != ARRAY_TYPE)
7335         {
7336           cp_error ("variable `%#D' has initializer but incomplete type",
7337                     decl);
7338           initialized = 0;
7339           type = TREE_TYPE (decl) = error_mark_node;
7340         }
7341       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7342         {
7343           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7344             cp_error ("elements of array `%#D' have incomplete type", decl);
7345           /* else we already gave an error in start_decl.  */
7346           initialized = 0;
7347         }
7348     }
7349
7350   if (!initialized
7351       && TREE_CODE (decl) != TYPE_DECL
7352       && TREE_CODE (decl) != TEMPLATE_DECL
7353       && type != error_mark_node
7354       && IS_AGGR_TYPE (type)
7355       && ! DECL_EXTERNAL (decl))
7356     {
7357       if ((! processing_template_decl || ! uses_template_parms (type))
7358           && !COMPLETE_TYPE_P (complete_type (type)))
7359         {
7360           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7361                  decl);
7362           /* Change the type so that assemble_variable will give
7363              DECL an rtl we can live with: (mem (const_int 0)).  */
7364           type = TREE_TYPE (decl) = error_mark_node;
7365         }
7366       else
7367         {
7368           /* If any base type in the hierarchy of TYPE needs a constructor,
7369              then we set initialized to 1.  This way any nodes which are
7370              created for the purposes of initializing this aggregate
7371              will live as long as it does.  This is necessary for global
7372              aggregates which do not have their initializers processed until
7373              the end of the file.  */
7374           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7375         }
7376     }
7377
7378   if (! initialized)
7379     DECL_INITIAL (decl) = NULL_TREE;
7380 }
7381
7382 /* Handle initialization of references.
7383    These three arguments are from `cp_finish_decl', and have the
7384    same meaning here that they do there.
7385
7386    Quotes on semantics can be found in ARM 8.4.3.  */
7387
7388 static void
7389 grok_reference_init (decl, type, init)
7390      tree decl, type, init;
7391 {
7392   tree tmp;
7393
7394   if (init == NULL_TREE)
7395     {
7396       if ((DECL_LANG_SPECIFIC (decl) == 0
7397            || DECL_IN_AGGR_P (decl) == 0)
7398           && ! DECL_THIS_EXTERN (decl))
7399         cp_error ("`%D' declared as reference but not initialized", decl);
7400       return;
7401     }
7402
7403   if (init == error_mark_node)
7404     return;
7405
7406   if (TREE_CODE (init) == CONSTRUCTOR)
7407     {
7408       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7409       return;
7410     }
7411
7412   if (TREE_CODE (init) == TREE_LIST)
7413     init = build_compound_expr (init);
7414
7415   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7416     init = convert_from_reference (init);
7417
7418   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7419       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7420     {
7421       /* Note: default conversion is only called in very special cases.  */
7422       init = default_conversion (init);
7423     }
7424
7425   /* Convert INIT to the reference type TYPE.  This may involve the
7426      creation of a temporary, whose lifetime must be the same as that
7427      of the reference.  If so, a DECL_STMT for the temporary will be
7428      added just after the DECL_STMT for DECL.  That's why we don't set
7429      DECL_INITIAL for local references (instead assigning to them
7430      explicitly); we need to allow the temporary to be initialized
7431      first.  */
7432   tmp = convert_to_reference
7433     (type, init, CONV_IMPLICIT,
7434      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7435      decl);
7436
7437   if (tmp == error_mark_node)
7438     return;
7439   else if (tmp != NULL_TREE)
7440     {
7441       init = tmp;
7442       tmp = save_expr (tmp);
7443       if (building_stmt_tree ())
7444         {
7445           /* Initialize the declaration.  */
7446           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7447           finish_expr_stmt (tmp);
7448         }
7449       else
7450         DECL_INITIAL (decl) = tmp;
7451     }
7452   else
7453     {
7454       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7455       return;
7456     }
7457
7458   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7459     {
7460       expand_static_init (decl, DECL_INITIAL (decl));
7461       DECL_INITIAL (decl) = NULL_TREE;
7462     }
7463   return;
7464 }
7465
7466 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7467    mucking with forces it does not comprehend (i.e. initialization with a
7468    constructor).  If we are at global scope and won't go into COMMON, fill
7469    it in with a dummy CONSTRUCTOR to force the variable into .data;
7470    otherwise we can use error_mark_node.  */
7471
7472 static tree
7473 obscure_complex_init (decl, init)
7474      tree decl, init;
7475 {
7476   if (! flag_no_inline && TREE_STATIC (decl))
7477     {
7478       if (extract_init (decl, init))
7479         return NULL_TREE;
7480     }
7481
7482 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7483   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7484     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7485                                  NULL_TREE);
7486   else
7487 #endif
7488     DECL_INITIAL (decl) = error_mark_node;
7489
7490   return init;
7491 }
7492
7493 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7494    array until we finish parsing the initializer.  If that's the
7495    situation we're in, update DECL accordingly.  */
7496
7497 static void
7498 maybe_deduce_size_from_array_init (decl, init)
7499      tree decl;
7500      tree init;
7501 {
7502   tree type = TREE_TYPE (decl);
7503
7504   if (TREE_CODE (type) == ARRAY_TYPE
7505       && TYPE_DOMAIN (type) == NULL_TREE
7506       && TREE_CODE (decl) != TYPE_DECL)
7507     {
7508       int do_default
7509         = (TREE_STATIC (decl)
7510            /* Even if pedantic, an external linkage array
7511               may have incomplete type at first.  */
7512            ? pedantic && ! DECL_EXTERNAL (decl)
7513            : !DECL_EXTERNAL (decl));
7514       tree initializer = init ? init : DECL_INITIAL (decl);
7515       int failure = complete_array_type (type, initializer, do_default);
7516
7517       if (failure == 1)
7518         cp_error ("initializer fails to determine size of `%D'", decl);
7519
7520       if (failure == 2)
7521         {
7522           if (do_default)
7523             cp_error ("array size missing in `%D'", decl);
7524           /* If a `static' var's size isn't known, make it extern as
7525              well as static, so it does not get allocated.  If it's not
7526              `static', then don't mark it extern; finish_incomplete_decl
7527              will give it a default size and it will get allocated.  */
7528           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7529             DECL_EXTERNAL (decl) = 1;
7530         }
7531
7532       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7533           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7534                               integer_zero_node))
7535         cp_error ("zero-size array `%D'", decl);
7536
7537       layout_decl (decl, 0);
7538     }
7539 }
7540
7541 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7542    any appropriate error messages regarding the layout.  */
7543
7544 static void
7545 layout_var_decl (decl)
7546      tree decl;
7547 {
7548   tree type = TREE_TYPE (decl);
7549 #if 0
7550   tree ttype = target_type (type);
7551 #endif
7552
7553   /* If we haven't already layed out this declaration, do so now.
7554      Note that we must not call complete type for an external object
7555      because it's type might involve templates that we are not
7556      supposed to isntantiate yet.  (And it's perfectly legal to say
7557      `extern X x' for some incomplete type `X'.)  */
7558   if (!DECL_EXTERNAL (decl))
7559     complete_type (type);
7560   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7561     layout_decl (decl, 0);
7562
7563   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7564     {
7565       /* An automatic variable with an incomplete type: that is an error.
7566          Don't talk about array types here, since we took care of that
7567          message in grokdeclarator.  */
7568       cp_error ("storage size of `%D' isn't known", decl);
7569       TREE_TYPE (decl) = error_mark_node;
7570     }
7571 #if 0
7572   /* Keep this code around in case we later want to control debug info
7573      based on whether a type is "used".  (jason 1999-11-11) */
7574
7575   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7576     /* Let debugger know it should output info for this type.  */
7577     note_debug_info_needed (ttype);
7578
7579   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7580     note_debug_info_needed (DECL_CONTEXT (decl));
7581 #endif
7582
7583   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7584       && DECL_SIZE (decl) != NULL_TREE
7585       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7586     {
7587       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7588         constant_expression_warning (DECL_SIZE (decl));
7589       else
7590         cp_error ("storage size of `%D' isn't constant", decl);
7591     }
7592 }
7593
7594 /* If a local static variable is declared in an inline function, or if
7595    we have a weak definition, we must endeavor to create only one
7596    instance of the variable at link-time.  */
7597
7598 static void
7599 maybe_commonize_var (decl)
7600      tree decl;
7601 {
7602   /* Static data in a function with comdat linkage also has comdat
7603      linkage.  */
7604   if (TREE_STATIC (decl)
7605       /* Don't mess with __FUNCTION__.  */
7606       && ! DECL_ARTIFICIAL (decl)
7607       && current_function_decl
7608       && DECL_CONTEXT (decl) == current_function_decl
7609       && (DECL_THIS_INLINE (current_function_decl)
7610           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7611       && TREE_PUBLIC (current_function_decl))
7612     {
7613       /* Rather than try to get this right with inlining, we suppress
7614          inlining of such functions.  */
7615       current_function_cannot_inline
7616         = "function with static variable cannot be inline";
7617
7618       /* If flag_weak, we don't need to mess with this, as we can just
7619          make the function weak, and let it refer to its unique local
7620          copy.  This works because we don't allow the function to be
7621          inlined.  */
7622       if (! flag_weak)
7623         {
7624           if (DECL_INTERFACE_KNOWN (current_function_decl))
7625             {
7626               TREE_PUBLIC (decl) = 1;
7627               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7628             }
7629           else if (DECL_INITIAL (decl) == NULL_TREE
7630                    || DECL_INITIAL (decl) == error_mark_node)
7631             {
7632               TREE_PUBLIC (decl) = 1;
7633               DECL_COMMON (decl) = 1;
7634             }
7635           /* else we lose. We can only do this if we can use common,
7636              which we can't if it has been initialized.  */
7637
7638           if (TREE_PUBLIC (decl))
7639             DECL_ASSEMBLER_NAME (decl)
7640               = build_static_name (current_function_decl, DECL_NAME (decl));
7641           else
7642             {
7643               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7644               cp_warning_at ("  you can work around this by removing the initializer", decl);
7645             }
7646         }
7647     }
7648   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7649     /* Set it up again; we might have set DECL_INITIAL since the last
7650        time.  */
7651     comdat_linkage (decl);
7652 }
7653
7654 /* Issue an error message if DECL is an uninitialized const variable.  */
7655
7656 static void
7657 check_for_uninitialized_const_var (decl)
7658      tree decl;
7659 {
7660   tree type = TREE_TYPE (decl);
7661
7662   /* ``Unless explicitly declared extern, a const object does not have
7663      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7664      7.1.6 */
7665   if (TREE_CODE (decl) == VAR_DECL
7666       && TREE_CODE (type) != REFERENCE_TYPE
7667       && CP_TYPE_CONST_P (type)
7668       && !TYPE_NEEDS_CONSTRUCTING (type)
7669       && !DECL_INITIAL (decl))
7670     cp_error ("uninitialized const `%D'", decl);
7671 }
7672
7673 /* Verify INIT (the initializer for DECL), and record the
7674    initialization in DECL_INITIAL, if appropriate.  Returns a new
7675    value for INIT.  */
7676
7677 static tree
7678 check_initializer (decl, init)
7679      tree decl;
7680      tree init;
7681 {
7682   tree type;
7683
7684   if (TREE_CODE (decl) == FIELD_DECL)
7685     return init;
7686
7687   type = TREE_TYPE (decl);
7688
7689   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7690   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7691     init = NULL_TREE;
7692
7693   /* Check the initializer.  */
7694   if (init)
7695     {
7696       /* Things that are going to be initialized need to have complete
7697          type.  */
7698       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7699
7700       if (type == error_mark_node)
7701         /* We will have already complained.  */
7702         init = NULL_TREE;
7703       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7704         {
7705           cp_error ("variable-sized object `%D' may not be initialized", decl);
7706           init = NULL_TREE;
7707         }
7708       else if (TREE_CODE (type) == ARRAY_TYPE
7709                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7710         {
7711           cp_error ("elements of array `%#D' have incomplete type", decl);
7712           init = NULL_TREE;
7713         }
7714       else if (!COMPLETE_TYPE_P (type))
7715         {
7716           cp_error ("`%D' has incomplete type", decl);
7717           TREE_TYPE (decl) = error_mark_node;
7718           init = NULL_TREE;
7719         }
7720     }
7721
7722   if (TREE_CODE (decl) == CONST_DECL)
7723     {
7724       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7725
7726       DECL_INITIAL (decl) = init;
7727
7728       /* This will keep us from needing to worry about our obstacks.  */
7729       my_friendly_assert (init != NULL_TREE, 149);
7730       init = NULL_TREE;
7731     }
7732   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7733     {
7734       if (TREE_STATIC (decl))
7735         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7736       grok_reference_init (decl, type, init);
7737       init = NULL_TREE;
7738     }
7739   else if (init)
7740     {
7741       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7742         {
7743           if (TREE_CODE (type) == ARRAY_TYPE)
7744             init = digest_init (type, init, (tree *) 0);
7745           else if (TREE_CODE (init) == CONSTRUCTOR
7746                    && TREE_HAS_CONSTRUCTOR (init))
7747             {
7748               if (TYPE_NON_AGGREGATE_CLASS (type))
7749                 {
7750                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7751                             decl);
7752                   init = error_mark_node;
7753                 }
7754               else
7755                 goto dont_use_constructor;
7756             }
7757         }
7758       else
7759         {
7760         dont_use_constructor:
7761           if (TREE_CODE (init) != TREE_VEC)
7762             init = store_init_value (decl, init);
7763         }
7764
7765       if (init)
7766         /* We must hide the initializer so that expand_decl
7767            won't try to do something it does not understand.  */
7768         init = obscure_complex_init (decl, init);
7769     }
7770   else if (DECL_EXTERNAL (decl))
7771     ;
7772   else if (TYPE_P (type)
7773            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7774     {
7775       tree core_type = strip_array_types (type);
7776
7777       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7778         {
7779           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7780             cp_error ("structure `%D' with uninitialized const members", decl);
7781           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7782             cp_error ("structure `%D' with uninitialized reference members",
7783                       decl);
7784         }
7785
7786       check_for_uninitialized_const_var (decl);
7787
7788       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7789         init = obscure_complex_init (decl, NULL_TREE);
7790
7791     }
7792   else
7793     check_for_uninitialized_const_var (decl);
7794
7795   return init;
7796 }
7797
7798 /* If DECL is not a local variable, give it RTL.  */
7799
7800 static void
7801 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7802      tree decl;
7803      tree init;
7804      const char *asmspec;
7805 {
7806   int toplev;
7807   tree type;
7808
7809   type = TREE_TYPE (decl);
7810   toplev = toplevel_bindings_p ();
7811
7812   /* Handle non-variables up front.  */
7813   if (TREE_CODE (decl) != VAR_DECL)
7814     {
7815       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7816       return;
7817     }
7818
7819   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7820   if (asmspec)
7821     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7822
7823   if (DECL_VIRTUAL_P (decl))
7824     make_decl_rtl (decl, NULL_PTR, toplev);
7825   else if (TREE_READONLY (decl)
7826            && DECL_INITIAL (decl) != NULL_TREE
7827            && DECL_INITIAL (decl) != error_mark_node
7828            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7829     {
7830       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7831
7832       if (toplev && ! TREE_PUBLIC (decl))
7833         {
7834           /* If this is a static const, change its apparent linkage
7835              if it belongs to a #pragma interface.  */
7836           if (!interface_unknown)
7837             {
7838               TREE_PUBLIC (decl) = 1;
7839               DECL_EXTERNAL (decl) = interface_only;
7840             }
7841           make_decl_rtl (decl, asmspec, toplev);
7842         }
7843       else if (toplev)
7844         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7845     }
7846   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7847     {
7848       my_friendly_assert (TREE_STATIC (decl), 19990828);
7849
7850       if (init == NULL_TREE
7851 #ifdef DEFAULT_STATIC_DEFS
7852           /* If this code is dead, then users must
7853              explicitly declare static member variables
7854              outside the class def'n as well.  */
7855           && TYPE_NEEDS_CONSTRUCTING (type)
7856 #endif
7857           )
7858         {
7859           DECL_EXTERNAL (decl) = 1;
7860           make_decl_rtl (decl, asmspec, 1);
7861         }
7862       else
7863         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7864     }
7865   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7866            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7867     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7868 }
7869
7870 /* Create RTL for the local static variable DECL.  */
7871
7872 void
7873 make_rtl_for_local_static (decl)
7874      tree decl;
7875 {
7876   const char *asmspec = NULL;
7877
7878   /* If we inlined this variable, we could see it's declaration
7879      again.  */
7880   if (DECL_RTL (decl))
7881     return;
7882
7883   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7884     {
7885       /* The only way this situaton can occur is if the
7886          user specified a name for this DECL using the
7887          `attribute' syntax.  */
7888       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7889       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7890     }
7891
7892   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7893 }
7894
7895 /* The old ARM scoping rules injected variables declared in the
7896    initialization statement of a for-statement into the surrounding
7897    scope.  We support this usage, in order to be backward-compatible.
7898    DECL is a just-declared VAR_DECL; if necessary inject its
7899    declaration into the surrounding scope.  */
7900
7901 void
7902 maybe_inject_for_scope_var (decl)
7903      tree decl;
7904 {
7905   if (current_binding_level->is_for_scope)
7906     {
7907       struct binding_level *outer
7908         = current_binding_level->level_chain;
7909
7910       /* Check to see if the same name is already bound at the outer
7911          level, either because it was directly declared, or because a
7912          dead for-decl got preserved.  In either case, the code would
7913          not have been valid under the ARM scope rules, so clear
7914          is_for_scope for the current_binding_level.
7915
7916          Otherwise, we need to preserve the temp slot for decl to last
7917          into the outer binding level.  */
7918
7919       tree outer_binding
7920         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7921
7922       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7923           && (TREE_CODE (BINDING_VALUE (outer_binding))
7924               == VAR_DECL)
7925           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7926         {
7927           BINDING_VALUE (outer_binding)
7928             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7929           current_binding_level->is_for_scope = 0;
7930         }
7931       else if (DECL_IN_MEMORY_P (decl))
7932         preserve_temp_slots (DECL_RTL (decl));
7933     }
7934 }
7935
7936 /* Generate code to initialize DECL (a local variable).  */
7937
7938 void
7939 initialize_local_var (decl, init, flags)
7940      tree decl;
7941      tree init;
7942      int flags;
7943 {
7944   tree type = TREE_TYPE (decl);
7945
7946   /* If the type is bogus, don't bother initializing the variable.  */
7947   if (type == error_mark_node)
7948     return;
7949
7950   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7951     {
7952       /* If we used it already as memory, it must stay in memory.  */
7953       DECL_INITIAL (decl) = NULL_TREE;
7954       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7955     }
7956
7957   /* Local statics are handled differently from ordinary automatic
7958      variables.  */
7959   if (TREE_STATIC (decl))
7960     {
7961       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7962           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7963         expand_static_init (decl, init);
7964       return;
7965     }
7966
7967   if (DECL_SIZE (decl) && type != error_mark_node)
7968     {
7969       int already_used;
7970
7971       /* Compute and store the initial value.  */
7972       already_used = TREE_USED (decl) || TREE_USED (type);
7973
7974       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7975         {
7976           int saved_stmts_are_full_exprs_p;
7977
7978           emit_line_note (DECL_SOURCE_FILE (decl),
7979                           DECL_SOURCE_LINE (decl));
7980           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7981           stmts_are_full_exprs_p = 1;
7982           finish_expr_stmt (build_aggr_init (decl, init, flags));
7983           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7984         }
7985
7986       /* Set this to 0 so we can tell whether an aggregate which was
7987          initialized was ever used.  Don't do this if it has a
7988          destructor, so we don't complain about the 'resource
7989          allocation is initialization' idiom.  Now set
7990          attribute((unused)) on types so decls of that type will be
7991          marked used. (see TREE_USED, above.)  */
7992       if (TYPE_NEEDS_CONSTRUCTING (type)
7993           && ! already_used
7994           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7995           && DECL_NAME (decl))
7996         TREE_USED (decl) = 0;
7997       else if (already_used)
7998         TREE_USED (decl) = 1;
7999     }
8000 }
8001
8002 /* Generate code to destroy DECL (a local variable).  */
8003
8004 static void
8005 destroy_local_var (decl)
8006      tree decl;
8007 {
8008   tree type = TREE_TYPE (decl);
8009   tree cleanup;
8010
8011   /* Only variables get cleaned up.  */
8012   if (TREE_CODE (decl) != VAR_DECL)
8013     return;
8014
8015   /* And only things with destructors need cleaning up.  */
8016   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8017     return;
8018
8019   if (TREE_CODE (decl) == VAR_DECL &&
8020       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8021     /* We don't clean up things that aren't defined in this
8022        translation unit, or that need a static cleanup.  The latter
8023        are handled by finish_file.  */
8024     return;
8025
8026   /* Compute the cleanup.  */
8027   cleanup = maybe_build_cleanup (decl);
8028
8029   /* Record the cleanup required for this declaration.  */
8030   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8031       && cleanup)
8032     finish_decl_cleanup (decl, cleanup);
8033 }
8034
8035 /* Let the back-end know about DECL.  */
8036
8037 void
8038 emit_local_var (decl)
8039      tree decl;
8040 {
8041   /* Create RTL for this variable.  */
8042   if (DECL_RTL (decl))
8043     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
8044        All other local variables are assigned RTL in this function.  */
8045     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
8046                         19990828);
8047   else
8048     {
8049       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
8050         /* The user must have specified an assembler name for this
8051            variable.  Set that up now.  */
8052         rest_of_decl_compilation
8053           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
8054            /*top_level=*/0, /*at_end=*/0);
8055       else
8056         expand_decl (decl);
8057     }
8058
8059   /* Actually do the initialization.  */
8060   if (stmts_are_full_exprs_p)
8061     expand_start_target_temps ();
8062
8063   expand_decl_init (decl);
8064
8065   if (stmts_are_full_exprs_p)
8066     expand_end_target_temps ();
8067 }
8068
8069 /* Finish processing of a declaration;
8070    install its line number and initial value.
8071    If the length of an array type is not known before,
8072    it must be determined now, from the initial value, or it is an error.
8073
8074    INIT0 holds the value of an initializer that should be allowed to escape
8075    the normal rules.
8076
8077    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8078    if the (init) syntax was used.  */
8079
8080 void
8081 cp_finish_decl (decl, init, asmspec_tree, flags)
8082      tree decl, init;
8083      tree asmspec_tree;
8084      int flags;
8085 {
8086   register tree type;
8087   tree ttype = NULL_TREE;
8088   const char *asmspec = NULL;
8089   int was_readonly = 0;
8090
8091   if (! decl)
8092     {
8093       if (init)
8094         error ("assignment (not initialization) in declaration");
8095       return;
8096     }
8097
8098   /* If a name was specified, get the string.  */
8099   if (asmspec_tree)
8100       asmspec = TREE_STRING_POINTER (asmspec_tree);
8101
8102   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8103     {
8104       cp_error ("cannot initialize `%D' to namespace `%D'",
8105                 decl, init);
8106       init = NULL_TREE;
8107     }
8108
8109   if (current_class_type
8110       && CP_DECL_CONTEXT (decl) == current_class_type
8111       && TYPE_BEING_DEFINED (current_class_type)
8112       && (DECL_INITIAL (decl) || init))
8113     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8114
8115   if (TREE_CODE (decl) == VAR_DECL
8116       && DECL_CONTEXT (decl)
8117       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8118       && DECL_CONTEXT (decl) != current_namespace
8119       && init)
8120     {
8121       /* Leave the namespace of the object. */
8122       pop_decl_namespace ();
8123     }
8124
8125   type = TREE_TYPE (decl);
8126
8127   if (type == error_mark_node)
8128     return;
8129
8130   /* Add this declaration to the statement-tree.  */
8131   if (building_stmt_tree () && at_function_scope_p ())
8132     add_decl_stmt (decl);
8133
8134   if (TYPE_HAS_MUTABLE_P (type))
8135     TREE_READONLY (decl) = 0;
8136
8137   if (processing_template_decl)
8138     {
8139       if (init && DECL_INITIAL (decl))
8140         DECL_INITIAL (decl) = init;
8141       goto finish_end0;
8142     }
8143
8144   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8145   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8146
8147   /* Take care of TYPE_DECLs up front.  */
8148   if (TREE_CODE (decl) == TYPE_DECL)
8149     {
8150       if (init && DECL_INITIAL (decl))
8151         {
8152           /* typedef foo = bar; store the type of bar as the type of foo.  */
8153           TREE_TYPE (decl) = type = TREE_TYPE (init);
8154           DECL_INITIAL (decl) = init = NULL_TREE;
8155         }
8156       if (type != error_mark_node
8157           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8158         {
8159           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8160             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8161           set_identifier_type_value (DECL_NAME (decl), type);
8162           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8163         }
8164       GNU_xref_decl (current_function_decl, decl);
8165
8166       /* If we have installed this as the canonical typedef for this
8167          type, and that type has not been defined yet, delay emitting
8168          the debug information for it, as we will emit it later.  */
8169       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8170           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8171         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8172
8173       rest_of_decl_compilation (decl, NULL_PTR,
8174                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8175       goto finish_end;
8176     }
8177
8178   if (TREE_CODE (decl) != FUNCTION_DECL)
8179     ttype = target_type (type);
8180
8181   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8182       && TYPE_NEEDS_CONSTRUCTING (type))
8183     {
8184       /* Currently, GNU C++ puts constants in text space, making them
8185          impossible to initialize.  In the future, one would hope for
8186          an operating system which understood the difference between
8187          initialization and the running of a program.  */
8188       was_readonly = 1;
8189       TREE_READONLY (decl) = 0;
8190     }
8191
8192   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8193     {
8194       /* This must override the asm specifier which was placed by
8195          grokclassfn.  Lay this out fresh.  */
8196       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8197       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8198       make_decl_rtl (decl, asmspec, 0);
8199     }
8200
8201   /* Deduce size of array from initialization, if not already known.  */
8202   maybe_deduce_size_from_array_init (decl, init);
8203   init = check_initializer (decl, init);
8204
8205   GNU_xref_decl (current_function_decl, decl);
8206
8207   if (TREE_CODE (decl) == VAR_DECL)
8208     layout_var_decl (decl);
8209
8210   /* Output the assembler code and/or RTL code for variables and functions,
8211      unless the type is an undefined structure or union.
8212      If not, it will get done when the type is completed.  */
8213   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8214       || TREE_CODE (decl) == RESULT_DECL)
8215     {
8216       if (TREE_CODE (decl) == VAR_DECL)
8217         maybe_commonize_var (decl);
8218
8219       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8220
8221       if (TREE_CODE (type) == FUNCTION_TYPE
8222           || TREE_CODE (type) == METHOD_TYPE)
8223         abstract_virtuals_error (decl,
8224                                  strip_array_types (TREE_TYPE (type)));
8225       else
8226         abstract_virtuals_error (decl, strip_array_types (type));
8227
8228       if (TREE_CODE (decl) == FUNCTION_DECL)
8229         ;
8230       else if (DECL_EXTERNAL (decl)
8231                && ! (DECL_LANG_SPECIFIC (decl)
8232                      && DECL_NOT_REALLY_EXTERN (decl)))
8233         {
8234           if (init)
8235             DECL_INITIAL (decl) = init;
8236         }
8237       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8238         {
8239           /* This is a local declaration.  */
8240           if (doing_semantic_analysis_p ())
8241             maybe_inject_for_scope_var (decl);
8242           /* Initialize the local variable.  But, if we're building a
8243              statement-tree, we'll do the initialization when we
8244              expand the tree.  */
8245           if (processing_template_decl)
8246             {
8247               if (init || DECL_INITIAL (decl) == error_mark_node)
8248                 DECL_INITIAL (decl) = init;
8249             }
8250           else
8251             {
8252               /* If we're not building RTL, then we need to do so
8253                  now.  */
8254               if (!building_stmt_tree ())
8255                 emit_local_var (decl);
8256               /* Initialize the variable.  */
8257               initialize_local_var (decl, init, flags);
8258               /* Clean up the variable.  */
8259               destroy_local_var (decl);
8260             }
8261         }
8262       else if (TREE_STATIC (decl) && type != error_mark_node)
8263         {
8264           /* Cleanups for static variables are handled by `finish_file'.  */
8265           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8266               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8267             expand_static_init (decl, init);
8268         }
8269     finish_end0:
8270
8271       /* Undo call to `pushclass' that was done in `start_decl'
8272          due to initialization of qualified member variable.
8273          I.e., Foo::x = 10;  */
8274       {
8275         tree context = CP_DECL_CONTEXT (decl);
8276         if (context
8277             && TYPE_P (context)
8278             && (TREE_CODE (decl) == VAR_DECL
8279                 /* We also have a pushclass done that we need to undo here
8280                    if we're at top level and declare a method.  */
8281                 || TREE_CODE (decl) == FUNCTION_DECL)
8282             /* If size hasn't been set, we're still defining it,
8283                and therefore inside the class body; don't pop
8284                the binding level..  */
8285             && COMPLETE_TYPE_P (context)
8286             && context == current_class_type)
8287           pop_nested_class ();
8288       }
8289     }
8290
8291  finish_end:
8292
8293   if (was_readonly)
8294     TREE_READONLY (decl) = 1;
8295 }
8296
8297 /* This is here for a midend callback from c-common.c */
8298
8299 void
8300 finish_decl (decl, init, asmspec_tree)
8301      tree decl, init;
8302      tree asmspec_tree;
8303 {
8304   cp_finish_decl (decl, init, asmspec_tree, 0);
8305 }
8306
8307 /* Returns a declaration for a VAR_DECL as if:
8308
8309      extern "C" TYPE NAME;
8310
8311    had been seen.  Used to create compiler-generated global
8312    variables.  */
8313
8314 tree
8315 declare_global_var (name, type)
8316      tree name;
8317      tree type;
8318 {
8319   tree decl;
8320
8321   push_to_top_level ();
8322   decl = build_decl (VAR_DECL, name, type);
8323   TREE_PUBLIC (decl) = 1;
8324   DECL_EXTERNAL (decl) = 1;
8325   DECL_ARTIFICIAL (decl) = 1;
8326   pushdecl (decl);
8327   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8328   pop_from_top_level ();
8329
8330   return decl;
8331 }
8332
8333 /* Returns a pointer to the `atexit' function.  Note that if
8334    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8335    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8336
8337 static tree
8338 get_atexit_node ()
8339 {
8340   tree atexit_fndecl;
8341   tree arg_types;
8342   tree fn_type;
8343   tree fn_ptr_type;
8344   const char *name;
8345
8346   if (atexit_node)
8347     return atexit_node;
8348
8349   if (flag_use_cxa_atexit)
8350     {
8351       /* The declaration for `__cxa_atexit' is:
8352
8353            int __cxa_atexit (void (*)(void *), void *, void *)
8354
8355          We build up the argument types and then then function type
8356          itself.  */
8357
8358       /* First, build the pointer-to-function type for the first
8359          argument.  */
8360       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8361       fn_type = build_function_type (void_type_node, arg_types);
8362       fn_ptr_type = build_pointer_type (fn_type);
8363       /* Then, build the rest of the argument types.  */
8364       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8365       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8366       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8367       /* And the final __cxa_atexit type.  */
8368       fn_type = build_function_type (integer_type_node, arg_types);
8369       fn_ptr_type = build_pointer_type (fn_type);
8370       name = "__cxa_atexit";
8371     }
8372   else
8373     {
8374       /* The declaration for `atexit' is:
8375
8376            int atexit (void (*)());
8377
8378          We build up the argument types and then then function type
8379          itself.  */
8380       fn_type = build_function_type (void_type_node, void_list_node);
8381       fn_ptr_type = build_pointer_type (fn_type);
8382       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8383       /* Build the final atexit type.  */
8384       fn_type = build_function_type (integer_type_node, arg_types);
8385       name = "atexit";
8386     }
8387
8388   /* Now, build the function declaration.  */
8389   push_lang_context (lang_name_c);
8390   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8391   mark_used (atexit_fndecl);
8392   pop_lang_context ();
8393   atexit_node = default_conversion (atexit_fndecl);
8394
8395   return atexit_node;
8396 }
8397
8398 /* Returns the __dso_handle VAR_DECL.  */
8399
8400 static tree
8401 get_dso_handle_node ()
8402 {
8403   if (dso_handle_node)
8404     return dso_handle_node;
8405
8406   /* Declare the variable.  */
8407   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8408                                         ptr_type_node);
8409
8410   return dso_handle_node;
8411 }
8412
8413 /* Begin a new function with internal linkage whose job will be simply
8414    to destroy some particular variable.  */
8415
8416 static tree
8417 start_cleanup_fn ()
8418 {
8419   static int counter = 0;
8420   int old_interface_unknown = interface_unknown;
8421   char name[32];
8422   tree parmtypes;
8423   tree fntype;
8424   tree fndecl;
8425
8426   push_to_top_level ();
8427
8428   /* No need to mangle this.  */
8429   push_lang_context (lang_name_c);
8430
8431   interface_unknown = 1;
8432
8433   /* Build the parameter-types.  */
8434   parmtypes = void_list_node;
8435   /* Functions passed to __cxa_atexit take an additional parameter.
8436      We'll just ignore it.  After we implement the new calling
8437      convention for destructors, we can eliminate the use of
8438      additional cleanup functions entirely in the -fnew-abi case.  */
8439   if (flag_use_cxa_atexit)
8440     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8441   /* Build the function type itself.  */
8442   fntype = build_function_type (void_type_node, parmtypes);
8443   /* Build the name of the function.  */
8444   sprintf (name, "__tcf_%d", counter++);
8445   /* Build the function declaration.  */
8446   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8447   /* It's a function with internal linkage, generated by the
8448      compiler.  */
8449   TREE_PUBLIC (fndecl) = 0;
8450   DECL_ARTIFICIAL (fndecl) = 1;
8451   /* Build the parameter.  */
8452   if (flag_use_cxa_atexit)
8453     {
8454       tree parmdecl;
8455
8456       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8457       DECL_CONTEXT (parmdecl) = fndecl;
8458       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8459       TREE_USED (parmdecl) = 1;
8460       DECL_ARGUMENTS (fndecl) = parmdecl;
8461     }
8462
8463   pushdecl (fndecl);
8464   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8465   do_pushlevel ();
8466
8467   interface_unknown = old_interface_unknown;
8468
8469   pop_lang_context ();
8470
8471   return current_function_decl;
8472 }
8473
8474 /* Finish the cleanup function begun by start_cleanup_fn.  */
8475
8476 static void
8477 end_cleanup_fn ()
8478 {
8479   do_poplevel ();
8480
8481   expand_body (finish_function (0));
8482
8483   pop_from_top_level ();
8484 }
8485
8486 /* Generate code to handle the destruction of DECL, an object with
8487    static storage duration.  */
8488
8489 void
8490 register_dtor_fn (decl)
8491      tree decl;
8492 {
8493   tree cleanup;
8494   tree compound_stmt;
8495   tree args;
8496   tree fcall;
8497
8498   int saved_flag_access_control;
8499
8500   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8501     return;
8502
8503   /* Call build_cleanup before we enter the anonymous function so that
8504      any access checks will be done relative to the current scope,
8505      rather than the scope of the anonymous function.  */
8506   build_cleanup (decl);
8507
8508   /* Now start the function.  */
8509   cleanup = start_cleanup_fn ();
8510
8511   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8512      to the original function, rather than the anonymous one.  That
8513      will make the back-end think that nested functions are in use,
8514      which causes confusion.  */
8515   saved_flag_access_control = flag_access_control;
8516   flag_access_control = 0;
8517   fcall = build_cleanup (decl);
8518   flag_access_control = saved_flag_access_control;
8519
8520   /* Create the body of the anonymous function.  */
8521   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8522   finish_expr_stmt (fcall);
8523   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8524   end_cleanup_fn ();
8525
8526   /* Call atexit with the cleanup function.  */
8527   mark_addressable (cleanup);
8528   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8529   if (flag_use_cxa_atexit)
8530     {
8531       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8532       args = tree_cons (NULL_TREE, null_pointer_node, args);
8533       args = tree_cons (NULL_TREE, cleanup, args);
8534     }
8535   else
8536     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8537   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8538 }
8539
8540 void
8541 expand_static_init (decl, init)
8542      tree decl;
8543      tree init;
8544 {
8545   tree oldstatic = value_member (decl, static_aggregates);
8546
8547   if (oldstatic)
8548     {
8549       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8550         cp_error ("multiple initializations given for `%D'", decl);
8551     }
8552   else if (! toplevel_bindings_p ())
8553     {
8554       /* Emit code to perform this initialization but once.  */
8555       tree temp;
8556       tree if_stmt;
8557       tree then_clause;
8558       tree assignment;
8559       tree temp_init;
8560
8561       /* Emit code to perform this initialization but once.  This code
8562          looks like:
8563
8564            static int temp = 0;
8565            if (!temp) {
8566              // Do initialization.
8567              temp = 1;
8568              // Register variable for destruction at end of program.
8569            }
8570
8571          Note that the `temp' variable is only set to 1 *after* the
8572          initialization is complete.  This ensures that an exception,
8573          thrown during the construction, will cause the variable to
8574          reinitialized when we pass through this code again, as per:
8575
8576            [stmt.dcl]
8577
8578            If the initialization exits by throwing an exception, the
8579            initialization is not complete, so it will be tried again
8580            the next time control enters the declaration.
8581
8582          In theory, this process should be thread-safe, too; multiple
8583          threads should not be able to initialize the variable more
8584          than once.  We don't yet attempt to ensure thread-safety.  */
8585       temp = get_temp_name (integer_type_node, 1);
8586       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8587
8588       /* Begin the conditional initialization.  */
8589       if_stmt = begin_if_stmt ();
8590       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8591                                             integer_zero_node),
8592                            if_stmt);
8593       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8594
8595       /* Do the initialization itself.  */
8596       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8597           || (init && TREE_CODE (init) == TREE_LIST))
8598         assignment = build_aggr_init (decl, init, 0);
8599       else if (init)
8600         /* The initialization we're doing here is just a bitwise
8601            copy.  */
8602         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8603       else
8604         assignment = NULL_TREE;
8605
8606       /* Once the assignment is complete, set TEMP to 1.  Since the
8607          construction of the static object is complete at this point,
8608          we want to make sure TEMP is set to 1 even if a temporary
8609          constructed during the initialization throws an exception
8610          when it is destroyed.  So, we combine the initialization and
8611          the assignment to TEMP into a single expression, ensuring
8612          that when we call finish_expr_stmt the cleanups will not be
8613          run until after TEMP is set to 1.  */
8614       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8615       if (assignment)
8616         {
8617           assignment = tree_cons (NULL_TREE, assignment,
8618                                   build_tree_list (NULL_TREE,
8619                                                    temp_init));
8620           assignment = build_compound_expr (assignment);
8621         }
8622       else
8623         assignment = temp_init;
8624       finish_expr_stmt (assignment);
8625
8626       /* Use atexit to register a function for destroying this static
8627          variable.  */
8628       register_dtor_fn (decl);
8629
8630       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8631       finish_then_clause (if_stmt);
8632       finish_if_stmt ();
8633     }
8634   else
8635     static_aggregates = tree_cons (init, decl, static_aggregates);
8636 }
8637
8638 /* Finish the declaration of a catch-parameter.  */
8639
8640 tree
8641 start_handler_parms (declspecs, declarator)
8642      tree declspecs;
8643      tree declarator;
8644 {
8645   tree decl;
8646   if (declspecs)
8647     {
8648       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8649                              1, NULL_TREE);
8650       if (decl == NULL_TREE)
8651         error ("invalid catch parameter");
8652     }
8653   else
8654     decl = NULL_TREE;
8655
8656   return decl;
8657 }
8658
8659 \f
8660 /* Make TYPE a complete type based on INITIAL_VALUE.
8661    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8662    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8663
8664 int
8665 complete_array_type (type, initial_value, do_default)
8666      tree type, initial_value;
8667      int do_default;
8668 {
8669   register tree maxindex = NULL_TREE;
8670   int value = 0;
8671
8672   if (initial_value)
8673     {
8674       /* Note MAXINDEX  is really the maximum index,
8675          one less than the size.  */
8676       if (TREE_CODE (initial_value) == STRING_CST)
8677         {
8678           int eltsize
8679             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8680           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8681                                    / eltsize) - 1, 0);
8682         }
8683       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8684         {
8685           tree elts = CONSTRUCTOR_ELTS (initial_value);
8686
8687           maxindex = ssize_int (-1);
8688           for (; elts; elts = TREE_CHAIN (elts))
8689             {
8690               if (TREE_PURPOSE (elts))
8691                 maxindex = TREE_PURPOSE (elts);
8692               else
8693                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8694             }
8695           maxindex = copy_node (maxindex);
8696         }
8697       else
8698         {
8699           /* Make an error message unless that happened already.  */
8700           if (initial_value != error_mark_node)
8701             value = 1;
8702           else
8703             initial_value = NULL_TREE;
8704
8705           /* Prevent further error messages.  */
8706           maxindex = build_int_2 (0, 0);
8707         }
8708     }
8709
8710   if (!maxindex)
8711     {
8712       if (do_default)
8713         maxindex = build_int_2 (0, 0);
8714       value = 2;
8715     }
8716
8717   if (maxindex)
8718     {
8719       tree itype;
8720       tree domain;
8721
8722       domain = build_index_type (maxindex);
8723       TYPE_DOMAIN (type) = domain;
8724
8725       if (! TREE_TYPE (maxindex))
8726         TREE_TYPE (maxindex) = domain;
8727       if (initial_value)
8728         itype = TREE_TYPE (initial_value);
8729       else
8730         itype = NULL;
8731       if (itype && !TYPE_DOMAIN (itype))
8732         TYPE_DOMAIN (itype) = domain;
8733       /* The type of the main variant should never be used for arrays
8734          of different sizes.  It should only ever be completed with the
8735          size of the array.  */
8736       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8737         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8738     }
8739
8740   /* Lay out the type now that we can get the real answer.  */
8741
8742   layout_type (type);
8743
8744   return value;
8745 }
8746 \f
8747 /* Return zero if something is declared to be a member of type
8748    CTYPE when in the context of CUR_TYPE.  STRING is the error
8749    message to print in that case.  Otherwise, quietly return 1.  */
8750
8751 static int
8752 member_function_or_else (ctype, cur_type, flags)
8753      tree ctype, cur_type;
8754      enum overload_flags flags;
8755 {
8756   if (ctype && ctype != cur_type)
8757     {
8758       if (flags == DTOR_FLAG)
8759         error ("destructor for alien class `%s' cannot be a member",
8760                TYPE_NAME_STRING (ctype));
8761       else
8762         error ("constructor for alien class `%s' cannot be a member",
8763                TYPE_NAME_STRING (ctype));
8764       return 0;
8765     }
8766   return 1;
8767 }
8768 \f
8769 /* Subroutine of `grokdeclarator'.  */
8770
8771 /* Generate errors possibly applicable for a given set of specifiers.
8772    This is for ARM $7.1.2.  */
8773
8774 static void
8775 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8776      tree object;
8777      const char *type;
8778      int virtualp, quals, friendp, raises, inlinep;
8779 {
8780   if (virtualp)
8781     cp_error ("`%D' declared as a `virtual' %s", object, type);
8782   if (inlinep)
8783     cp_error ("`%D' declared as an `inline' %s", object, type);
8784   if (quals)
8785     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8786               object, type);
8787   if (friendp)
8788     cp_error_at ("`%D' declared as a friend", object);
8789   if (raises)
8790     cp_error_at ("`%D' declared with an exception specification", object);
8791 }
8792
8793 /* CTYPE is class type, or null if non-class.
8794    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8795    or METHOD_TYPE.
8796    DECLARATOR is the function's name.
8797    VIRTUALP is truthvalue of whether the function is virtual or not.
8798    FLAGS are to be passed through to `grokclassfn'.
8799    QUALS are qualifiers indicating whether the function is `const'
8800    or `volatile'.
8801    RAISES is a list of exceptions that this function can raise.
8802    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8803    not look, and -1 if we should not call `grokclassfn' at all.
8804
8805    Returns `NULL_TREE' if something goes wrong, after issuing
8806    applicable error messages.  */
8807
8808 static tree
8809 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8810             raises, check, friendp, publicp, inlinep, funcdef_flag,
8811             template_count, in_namespace)
8812      tree ctype, type;
8813      tree declarator;
8814      tree orig_declarator;
8815      int virtualp;
8816      enum overload_flags flags;
8817      tree quals, raises;
8818      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8819      tree in_namespace;
8820 {
8821   tree cname, decl;
8822   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8823   int has_default_arg = 0;
8824   tree t;
8825
8826   if (ctype)
8827     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8828       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8829   else
8830     cname = NULL_TREE;
8831
8832   if (raises)
8833     {
8834       type = build_exception_variant (type, raises);
8835     }
8836
8837   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8838   /* Propagate volatile out from type to decl. */
8839   if (TYPE_VOLATILE (type))
8840     TREE_THIS_VOLATILE (decl) = 1;
8841
8842   /* If this decl has namespace scope, set that up.  */
8843   if (in_namespace)
8844     set_decl_namespace (decl, in_namespace, friendp);
8845   else if (publicp && ! ctype)
8846     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8847
8848   /* `main' and builtins have implicit 'C' linkage.  */
8849   if ((MAIN_NAME_P (declarator)
8850        || (IDENTIFIER_LENGTH (declarator) > 10
8851            && IDENTIFIER_POINTER (declarator)[0] == '_'
8852            && IDENTIFIER_POINTER (declarator)[1] == '_'
8853            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8854       && current_lang_name == lang_name_cplusplus
8855       && ctype == NULL_TREE
8856       /* NULL_TREE means global namespace.  */
8857       && DECL_CONTEXT (decl) == NULL_TREE)
8858     DECL_LANGUAGE (decl) = lang_c;
8859
8860   /* Should probably propagate const out from type to decl I bet (mrs).  */
8861   if (staticp)
8862     {
8863       DECL_STATIC_FUNCTION_P (decl) = 1;
8864       DECL_CONTEXT (decl) = ctype;
8865     }
8866
8867   if (ctype)
8868     DECL_CONTEXT (decl) = ctype;
8869
8870   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8871     {
8872       if (processing_template_decl)
8873         error ("cannot declare `::main' to be a template");
8874       if (inlinep)
8875         error ("cannot declare `::main' to be inline");
8876       else if (! publicp)
8877         error ("cannot declare `::main' to be static");
8878       inlinep = 0;
8879       publicp = 1;
8880     }
8881
8882   /* Members of anonymous types and local classes have no linkage; make
8883      them internal.  */
8884   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8885                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8886     publicp = 0;
8887
8888   if (publicp)
8889     {
8890       /* [basic.link]: A name with no linkage (notably, the name of a class
8891          or enumeration declared in a local scope) shall not be used to
8892          declare an entity with linkage.
8893
8894          Only check this for public decls for now.  */
8895       t = no_linkage_check (TREE_TYPE (decl));
8896       if (t)
8897         {
8898           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8899             {
8900               if (DECL_EXTERN_C_P (decl))
8901                 /* Allow this; it's pretty common in C.  */;
8902               else
8903                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8904                             decl);
8905             }
8906           else
8907             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8908                         decl, t);
8909         }
8910     }
8911
8912   TREE_PUBLIC (decl) = publicp;
8913   if (! publicp)
8914     {
8915       DECL_INTERFACE_KNOWN (decl) = 1;
8916       DECL_NOT_REALLY_EXTERN (decl) = 1;
8917     }
8918
8919   if (inlinep)
8920     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8921
8922   DECL_EXTERNAL (decl) = 1;
8923   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8924     {
8925       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8926                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8927       quals = NULL_TREE;
8928     }
8929
8930   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8931     grok_op_properties (decl, virtualp, check < 0);
8932
8933   if (ctype && decl_function_context (decl))
8934     DECL_NO_STATIC_CHAIN (decl) = 1;
8935
8936   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8937     if (TREE_PURPOSE (t)
8938         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8939       {
8940         has_default_arg = 1;
8941         break;
8942       }
8943
8944   if (friendp
8945       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8946     {
8947       if (funcdef_flag)
8948         cp_error
8949           ("defining explicit specialization `%D' in friend declaration",
8950            orig_declarator);
8951       else
8952         {
8953           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8954             {
8955               /* Something like `template <class T> friend void f<T>()'.  */
8956               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8957                         orig_declarator);
8958               return NULL_TREE;
8959             }
8960
8961
8962           /* A friend declaration of the form friend void f<>().  Record
8963              the information in the TEMPLATE_ID_EXPR.  */
8964           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8965           DECL_TEMPLATE_INFO (decl)
8966             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8967                          TREE_OPERAND (orig_declarator, 1),
8968                          NULL_TREE);
8969
8970           if (has_default_arg)
8971             {
8972               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8973                         decl);
8974               return NULL_TREE;
8975             }
8976
8977           if (inlinep)
8978             {
8979               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8980                         decl);
8981               return NULL_TREE;
8982             }
8983         }
8984     }
8985
8986   if (has_default_arg)
8987     add_defarg_fn (decl);
8988
8989   /* Plain overloading: will not be grok'd by grokclassfn.  */
8990   if (! ctype && ! processing_template_decl
8991       && !DECL_EXTERN_C_P (decl)
8992       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8993     set_mangled_name_for_decl (decl);
8994
8995   if (funcdef_flag)
8996     /* Make the init_value nonzero so pushdecl knows this is not
8997        tentative.  error_mark_node is replaced later with the BLOCK.  */
8998     DECL_INITIAL (decl) = error_mark_node;
8999
9000   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9001     TREE_NOTHROW (decl) = 1;
9002
9003   /* Caller will do the rest of this.  */
9004   if (check < 0)
9005     return decl;
9006
9007   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
9008     DECL_CONSTRUCTOR_P (decl) = 1;
9009
9010   /* Function gets the ugly name, field gets the nice one.  This call
9011      may change the type of the function (because of default
9012      parameters)!  */
9013   if (ctype != NULL_TREE)
9014     grokclassfn (ctype, decl, flags, quals);
9015
9016   decl = check_explicit_specialization (orig_declarator, decl,
9017                                         template_count,
9018                                         2 * (funcdef_flag != 0) +
9019                                         4 * (friendp != 0));
9020   if (decl == error_mark_node)
9021     return NULL_TREE;
9022
9023   if (ctype != NULL_TREE
9024       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9025       && check)
9026     {
9027       tree old_decl;
9028
9029       old_decl = check_classfn (ctype, decl);
9030
9031       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9032         /* Because grokfndecl is always supposed to return a
9033            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9034            here.  We depend on our callers to figure out that its
9035            really a template that's being returned.  */
9036         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9037
9038       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9039           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9040         {
9041           /* Remove the `this' parm added by grokclassfn.
9042              XXX Isn't this done in start_function, too?  */
9043           revert_static_member_fn (decl);
9044           last_function_parms = TREE_CHAIN (last_function_parms);
9045         }
9046       if (old_decl && DECL_ARTIFICIAL (old_decl))
9047         cp_error ("definition of implicitly-declared `%D'", old_decl);
9048
9049       if (old_decl)
9050         {
9051           /* Since we've smashed OLD_DECL to its
9052              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9053           if (TREE_CODE (decl) == TEMPLATE_DECL)
9054             decl = DECL_TEMPLATE_RESULT (decl);
9055
9056           /* Attempt to merge the declarations.  This can fail, in
9057              the case of some illegal specialization declarations.  */
9058           if (!duplicate_decls (decl, old_decl))
9059             cp_error ("no `%#D' member function declared in class `%T'",
9060                       decl, ctype);
9061           return old_decl;
9062         }
9063     }
9064
9065   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9066     return NULL_TREE;
9067
9068   if (ctype == NULL_TREE || check)
9069     return decl;
9070
9071   if (virtualp)
9072     {
9073       DECL_VIRTUAL_P (decl) = 1;
9074       if (DECL_VINDEX (decl) == NULL_TREE)
9075         DECL_VINDEX (decl) = error_mark_node;
9076       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9077     }
9078
9079   return decl;
9080 }
9081
9082 static tree
9083 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9084      tree type;
9085      tree declarator;
9086      RID_BIT_TYPE *specbits_in;
9087      int initialized;
9088      int constp;
9089      tree in_namespace;
9090 {
9091   tree decl;
9092   RID_BIT_TYPE specbits;
9093
9094   specbits = *specbits_in;
9095
9096   if (TREE_CODE (type) == OFFSET_TYPE)
9097     {
9098       /* If you declare a static member so that it
9099          can be initialized, the code will reach here.  */
9100       tree basetype = TYPE_OFFSET_BASETYPE (type);
9101       type = TREE_TYPE (type);
9102       decl = build_lang_decl (VAR_DECL, declarator, type);
9103       DECL_CONTEXT (decl) = basetype;
9104       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9105          templates.  */
9106       if (!uses_template_parms (decl))
9107         {
9108           if (flag_new_abi)
9109             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9110           else
9111             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9112                                                             declarator);
9113         }
9114     }
9115   else
9116     {
9117       tree context;
9118
9119       if (in_namespace)
9120         context = in_namespace;
9121       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9122         context = current_namespace;
9123       else
9124         context = NULL_TREE;
9125
9126       if (processing_template_decl && context)
9127         /* For global variables, declared in a template, we need the
9128            full lang_decl.  */
9129         decl = build_lang_decl (VAR_DECL, declarator, type);
9130       else
9131         decl = build_decl (VAR_DECL, declarator, type);
9132
9133       if (context)
9134         set_decl_namespace (decl, context, 0);
9135
9136       context = DECL_CONTEXT (decl);
9137       if (declarator && context && current_lang_name != lang_name_c)
9138         {
9139           if (flag_new_abi)
9140             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9141           else
9142             DECL_ASSEMBLER_NAME (decl)
9143               = build_static_name (context, declarator);
9144         }
9145     }
9146
9147   if (in_namespace)
9148     set_decl_namespace (decl, in_namespace, 0);
9149
9150   if (RIDBIT_SETP (RID_EXTERN, specbits))
9151     {
9152       DECL_THIS_EXTERN (decl) = 1;
9153       DECL_EXTERNAL (decl) = !initialized;
9154     }
9155
9156   /* In class context, static means one per class,
9157      public access, and static storage.  */
9158   if (DECL_CLASS_SCOPE_P (decl))
9159     {
9160       TREE_PUBLIC (decl) = 1;
9161       TREE_STATIC (decl) = 1;
9162       DECL_EXTERNAL (decl) = 0;
9163     }
9164   /* At top level, either `static' or no s.c. makes a definition
9165      (perhaps tentative), and absence of `static' makes it public.  */
9166   else if (toplevel_bindings_p ())
9167     {
9168       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9169                             && (DECL_THIS_EXTERN (decl) || ! constp));
9170       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9171     }
9172   /* Not at top level, only `static' makes a static definition.  */
9173   else
9174     {
9175       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9176       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9177     }
9178
9179   if (TREE_PUBLIC (decl))
9180     {
9181       /* [basic.link]: A name with no linkage (notably, the name of a class
9182          or enumeration declared in a local scope) shall not be used to
9183          declare an entity with linkage.
9184
9185          Only check this for public decls for now.  */
9186       tree t = no_linkage_check (TREE_TYPE (decl));
9187       if (t)
9188         {
9189           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9190             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9191           else
9192             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9193                         decl, t);
9194         }
9195     }
9196
9197   return decl;
9198 }
9199
9200 /* Create and return a canonical pointer to member function type, for
9201    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9202
9203 tree
9204 build_ptrmemfunc_type (type)
9205      tree type;
9206 {
9207   tree fields[4];
9208   tree t;
9209   tree u;
9210   tree unqualified_variant = NULL_TREE;
9211
9212   /* If a canonical type already exists for this type, use it.  We use
9213      this method instead of type_hash_canon, because it only does a
9214      simple equality check on the list of field members.  */
9215
9216   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9217     return t;
9218
9219   /* Make sure that we always have the unqualified pointer-to-member
9220      type first.  */
9221   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9222     unqualified_variant
9223       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9224
9225   t = make_aggr_type (RECORD_TYPE);
9226   /* Let the front-end know this is a pointer to member function...  */
9227   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9228   /* ... and not really an aggregate.  */
9229   SET_IS_AGGR_TYPE (t, 0);
9230
9231   if (!flag_new_abi)
9232     {
9233       u = make_aggr_type (UNION_TYPE);
9234       SET_IS_AGGR_TYPE (u, 0);
9235       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9236       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9237                               delta_type_node);
9238       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9239       TYPE_NAME (u) = NULL_TREE;
9240
9241       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9242                               delta_type_node);
9243       fields[1] = build_decl (FIELD_DECL, index_identifier,
9244                               delta_type_node);
9245       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9246       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9247     }
9248   else
9249     {
9250       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9251       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9252                               delta_type_node);
9253       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9254     }
9255
9256   /* Zap out the name so that the back-end will give us the debugging
9257      information for this anonymous RECORD_TYPE.  */
9258   TYPE_NAME (t) = NULL_TREE;
9259
9260   /* If this is not the unqualified form of this pointer-to-member
9261      type, set the TYPE_MAIN_VARIANT for this type to be the
9262      unqualified type.  Since they are actually RECORD_TYPEs that are
9263      not variants of each other, we must do this manually.  */
9264   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9265     {
9266       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9267       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9268       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9269       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9270     }
9271
9272   /* Cache this pointer-to-member type so that we can find it again
9273      later.  */
9274   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9275
9276   /* Seems to be wanted.  */
9277   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9278
9279   return t;
9280 }
9281
9282 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9283    Check to see that the definition is valid.  Issue appropriate error
9284    messages.  Return 1 if the definition is particularly bad, or 0
9285    otherwise.  */
9286
9287 int
9288 check_static_variable_definition (decl, type)
9289      tree decl;
9290      tree type;
9291 {
9292   /* Motion 10 at San Diego: If a static const integral data member is
9293      initialized with an integral constant expression, the initializer
9294      may appear either in the declaration (within the class), or in
9295      the definition, but not both.  If it appears in the class, the
9296      member is a member constant.  The file-scope definition is always
9297      required.  */
9298   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9299     {
9300       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9301                 type);
9302       /* If we just return the declaration, crashes will sometimes
9303          occur.  We therefore return void_type_node, as if this was a
9304          friend declaration, to cause callers to completely ignore
9305          this declaration.  */
9306       return 1;
9307     }
9308   else if (!CP_TYPE_CONST_P (type))
9309     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9310               decl);
9311   else if (pedantic && !INTEGRAL_TYPE_P (type))
9312     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9313
9314   return 0;
9315 }
9316
9317 /* Given the SIZE (i.e., number of elements) in an array, compute an
9318    appropriate index type for the array.  If non-NULL, NAME is the
9319    name of the thing being declared.  */
9320
9321 tree
9322 compute_array_index_type (name, size)
9323      tree name;
9324      tree size;
9325 {
9326   tree itype;
9327
9328   /* The size might be the result of a cast. */
9329   STRIP_TYPE_NOPS (size);
9330
9331   /* It might be a const variable or enumeration constant.  */
9332   size = decl_constant_value (size);
9333
9334   /* If this involves a template parameter, it will be a constant at
9335      instantiation time, but we don't know what the value is yet.
9336      Even if no template parameters are involved, we may an expression
9337      that is not a constant; we don't even simplify `1 + 2' when
9338      processing a template.  */
9339   if (processing_template_decl)
9340     {
9341       /* Resolve a qualified reference to an enumerator or static
9342          const data member of ours.  */
9343       if (TREE_CODE (size) == SCOPE_REF
9344           && TREE_OPERAND (size, 0) == current_class_type)
9345         {
9346           tree t = lookup_field (current_class_type,
9347                                  TREE_OPERAND (size, 1), 0, 0);
9348           if (t)
9349             size = t;
9350         }
9351
9352       return build_index_type (build_min (MINUS_EXPR, sizetype,
9353                                           size, integer_one_node));
9354     }
9355
9356   /* The array bound must be an integer type.  */
9357   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9358       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9359       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9360     {
9361       if (name)
9362         cp_error ("size of array `%D' has non-integer type", name);
9363       else
9364         cp_error ("size of array has non-integer type");
9365       size = integer_one_node;
9366     }
9367
9368   /* Normally, the array-bound will be a constant.  */
9369   if (TREE_CONSTANT (size))
9370     {
9371       /* Check to see if the array bound overflowed.  Make that an
9372          error, no matter how generous we're being.  */
9373       int old_flag_pedantic_errors = flag_pedantic_errors;
9374       int old_pedantic = pedantic;
9375       pedantic = flag_pedantic_errors = 1;
9376       constant_expression_warning (size);
9377       pedantic = old_pedantic;
9378       flag_pedantic_errors = old_flag_pedantic_errors;
9379
9380       /* An array must have a positive number of elements.  */
9381       if (INT_CST_LT (size, integer_zero_node))
9382         {
9383           if (name)
9384             cp_error ("size of array `%D' is negative", name);
9385           else
9386             cp_error ("size of array is negative");
9387           size = integer_one_node;
9388         }
9389       /* Except that an extension we allow zero-sized arrays.  We
9390          always allow them in system headers because glibc uses
9391          them.  */
9392       else if (integer_zerop (size) && pedantic && !in_system_header)
9393         {
9394           if (name)
9395             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9396           else
9397             cp_pedwarn ("ISO C++ forbids zero-size array");
9398         }
9399     }
9400
9401   /* Compute the index of the largest element in the array.  It is
9402      one less than the number of elements in the array.  */
9403   itype
9404     = fold (build_binary_op (MINUS_EXPR,
9405                              cp_convert (ssizetype, size),
9406                              cp_convert (ssizetype,
9407                                          integer_one_node)));
9408
9409   /* Check for variable-sized arrays.  We allow such things as an
9410      extension, even though they are not allowed in ANSI/ISO C++.  */
9411   if (!TREE_CONSTANT (itype))
9412     {
9413       if (pedantic)
9414         {
9415           if (name)
9416             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9417                         name);
9418           else
9419             cp_pedwarn ("ISO C++ forbids variable-size array");
9420         }
9421
9422       /* Create a variable-sized array index type.  */
9423       itype = variable_size (itype);
9424     }
9425   /* Make sure that there was no overflow when creating to a signed
9426      index type.  (For example, on a 32-bit machine, an array with
9427      size 2^32 - 1 is too big.)  */
9428   else if (TREE_OVERFLOW (itype))
9429     {
9430       error ("overflow in array dimension");
9431       TREE_OVERFLOW (itype) = 0;
9432     }
9433
9434   /* Create and return the appropriate index type.  */
9435   return build_index_type (itype);
9436 }
9437
9438 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9439    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9440    with this type.  */
9441
9442 static tree
9443 create_array_type_for_decl (name, type, size)
9444      tree name;
9445      tree type;
9446      tree size;
9447 {
9448   tree itype = NULL_TREE;
9449   const char* error_msg;
9450
9451   /* If things have already gone awry, bail now.  */
9452   if (type == error_mark_node || size == error_mark_node)
9453     return error_mark_node;
9454
9455   /* Assume that everything will go OK.  */
9456   error_msg = NULL;
9457
9458   /* There are some types which cannot be array elements.  */
9459   switch (TREE_CODE (type))
9460     {
9461     case VOID_TYPE:
9462       error_msg = "array of void";
9463       break;
9464
9465     case FUNCTION_TYPE:
9466       error_msg = "array of functions";
9467       break;
9468
9469     case REFERENCE_TYPE:
9470       error_msg = "array of references";
9471       break;
9472
9473     case OFFSET_TYPE:
9474       error_msg = "array of data members";
9475       break;
9476
9477     case METHOD_TYPE:
9478       error_msg = "array of function members";
9479       break;
9480
9481     default:
9482       break;
9483     }
9484
9485   /* If something went wrong, issue an error-message and return.  */
9486   if (error_msg)
9487     {
9488       if (name)
9489         cp_error ("declaration of `%D' as %s", name, error_msg);
9490       else
9491         cp_error ("creating %s", error_msg);
9492
9493       return error_mark_node;
9494     }
9495
9496   /* [dcl.array]
9497
9498      The constant expressions that specify the bounds of the arrays
9499      can be omitted only for the first member of the sequence.  */
9500   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9501     {
9502       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9503                 name);
9504
9505       return error_mark_node;
9506     }
9507
9508   /* Figure out the index type for the array.  */
9509   if (size)
9510     itype = compute_array_index_type (name, size);
9511
9512   return build_cplus_array_type (type, itype);
9513 }
9514
9515 /* Check that it's OK to declare a function with the indicated TYPE.
9516    SFK indicates the kind of special function (if any) that this
9517    function is.  CTYPE is the class of which this function is a
9518    member.  OPTYPE is the type given in a conversion operator
9519    declaration.  Returns the actual return type of the function; that
9520    may be different than TYPE if an error occurs, or for certain
9521    special functions.  */
9522
9523 static tree
9524 check_special_function_return_type (sfk, type, ctype, optype)
9525      special_function_kind sfk;
9526      tree type;
9527      tree ctype;
9528      tree optype;
9529 {
9530   switch (sfk)
9531     {
9532     case sfk_constructor:
9533       if (type)
9534         cp_error ("return type specification for constructor invalid");
9535
9536       /* In the old ABI, we return `this'; in the new ABI we don't
9537          bother.  */
9538       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9539       break;
9540
9541     case sfk_destructor:
9542       if (type)
9543         cp_error ("return type specification for destructor invalid");
9544       type = void_type_node;
9545       break;
9546
9547     case sfk_conversion:
9548       if (type && !same_type_p (type, optype))
9549         cp_error ("operator `%T' declared to return `%T'", optype, type);
9550       else if (type)
9551         cp_pedwarn ("return type specified for `operator %T'",  optype);
9552       type = optype;
9553       break;
9554
9555     default:
9556       my_friendly_abort (20000408);
9557       break;
9558     }
9559
9560   return type;
9561 }
9562
9563 /* Given declspecs and a declarator,
9564    determine the name and type of the object declared
9565    and construct a ..._DECL node for it.
9566    (In one case we can return a ..._TYPE node instead.
9567     For invalid input we sometimes return 0.)
9568
9569    DECLSPECS is a chain of tree_list nodes whose value fields
9570     are the storage classes and type specifiers.
9571
9572    DECL_CONTEXT says which syntactic context this declaration is in:
9573      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9574      FUNCDEF for a function definition.  Like NORMAL but a few different
9575       error messages in each case.  Return value may be zero meaning
9576       this definition is too screwy to try to parse.
9577      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9578       handle member functions (which have FIELD context).
9579       Return value may be zero meaning this definition is too screwy to
9580       try to parse.
9581      PARM for a parameter declaration (either within a function prototype
9582       or before a function body).  Make a PARM_DECL, or return void_type_node.
9583      CATCHPARM for a parameter declaration before a catch clause.
9584      TYPENAME if for a typename (in a cast or sizeof).
9585       Don't make a DECL node; just return the ..._TYPE node.
9586      FIELD for a struct or union field; make a FIELD_DECL.
9587      BITFIELD for a field with specified width.
9588    INITIALIZED is 1 if the decl has an initializer.
9589
9590    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9591    normal attributes in TREE_PURPOSE, or NULL_TREE.
9592
9593    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9594    It may also be so in the PARM case, for a prototype where the
9595    argument type is specified but not the name.
9596
9597    This function is where the complicated C meanings of `static'
9598    and `extern' are interpreted.
9599
9600    For C++, if there is any monkey business to do, the function which
9601    calls this one must do it, i.e., prepending instance variables,
9602    renaming overloaded function names, etc.
9603
9604    Note that for this C++, it is an error to define a method within a class
9605    which does not belong to that class.
9606
9607    Except in the case where SCOPE_REFs are implicitly known (such as
9608    methods within a class being redundantly qualified),
9609    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9610    (class_name::decl_name).  The caller must also deal with this.
9611
9612    If a constructor or destructor is seen, and the context is FIELD,
9613    then the type gains the attribute TREE_HAS_x.  If such a declaration
9614    is erroneous, NULL_TREE is returned.
9615
9616    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9617    function, these are the qualifiers to give to the `this' pointer. We
9618    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9619
9620    May return void_type_node if the declarator turned out to be a friend.
9621    See grokfield for details.  */
9622
9623 tree
9624 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9625      tree declspecs;
9626      tree declarator;
9627      enum decl_context decl_context;
9628      int initialized;
9629      tree attrlist;
9630 {
9631   RID_BIT_TYPE specbits;
9632   int nclasses = 0;
9633   tree spec;
9634   tree type = NULL_TREE;
9635   int longlong = 0;
9636   int constp;
9637   int restrictp;
9638   int volatilep;
9639   int type_quals;
9640   int virtualp, explicitp, friendp, inlinep, staticp;
9641   int explicit_int = 0;
9642   int explicit_char = 0;
9643   int defaulted_int = 0;
9644   tree typedef_decl = NULL_TREE;
9645   const char *name;
9646   tree typedef_type = NULL_TREE;
9647   int funcdef_flag = 0;
9648   enum tree_code innermost_code = ERROR_MARK;
9649   int bitfield = 0;
9650 #if 0
9651   /* See the code below that used this.  */
9652   tree decl_machine_attr = NULL_TREE;
9653 #endif
9654   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9655      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9656   tree init = NULL_TREE;
9657
9658   /* Keep track of what sort of function is being processed
9659      so that we can warn about default return values, or explicit
9660      return values which do not match prescribed defaults.  */
9661   special_function_kind sfk = sfk_none;
9662
9663   tree dname = NULL_TREE;
9664   tree ctype = current_class_type;
9665   tree ctor_return_type = NULL_TREE;
9666   enum overload_flags flags = NO_SPECIAL;
9667   tree quals = NULL_TREE;
9668   tree raises = NULL_TREE;
9669   int template_count = 0;
9670   tree in_namespace = NULL_TREE;
9671   tree inner_attrs;
9672   int ignore_attrs;
9673
9674   RIDBIT_RESET_ALL (specbits);
9675   if (decl_context == FUNCDEF)
9676     funcdef_flag = 1, decl_context = NORMAL;
9677   else if (decl_context == MEMFUNCDEF)
9678     funcdef_flag = -1, decl_context = FIELD;
9679   else if (decl_context == BITFIELD)
9680     bitfield = 1, decl_context = FIELD;
9681
9682   /* Look inside a declarator for the name being declared
9683      and get it as a string, for an error message.  */
9684   {
9685     tree *next = &declarator;
9686     register tree decl;
9687     name = NULL;
9688
9689     while (next && *next)
9690       {
9691         decl = *next;
9692         switch (TREE_CODE (decl))
9693           {
9694           case TREE_LIST:
9695             /* For attributes.  */
9696             next = &TREE_VALUE (decl);
9697             break;
9698
9699           case COND_EXPR:
9700             ctype = NULL_TREE;
9701             next = &TREE_OPERAND (decl, 0);
9702             break;
9703
9704           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9705             {
9706               tree name = TREE_OPERAND (decl, 0);
9707               tree rename = NULL_TREE;
9708
9709               my_friendly_assert (flags == NO_SPECIAL, 152);
9710               flags = DTOR_FLAG;
9711               sfk = sfk_destructor;
9712               if (TREE_CODE (name) == TYPE_DECL)
9713                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9714               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9715               if (ctype == NULL_TREE)
9716                 {
9717                   if (current_class_type == NULL_TREE)
9718                     {
9719                       error ("destructors must be member functions");
9720                       flags = NO_SPECIAL;
9721                     }
9722                   else
9723                     {
9724                       tree t = constructor_name (current_class_name);
9725                       if (t != name)
9726                         rename = t;
9727                     }
9728                 }
9729               else
9730                 {
9731                   tree t = constructor_name (ctype);
9732                   if (t != name)
9733                     rename = t;
9734                 }
9735
9736               if (rename)
9737                 {
9738                   cp_error ("destructor `%T' must match class name `%T'",
9739                             name, rename);
9740                   TREE_OPERAND (decl, 0) = rename;
9741                 }
9742               next = &name;
9743             }
9744             break;
9745
9746           case ADDR_EXPR:       /* C++ reference declaration */
9747             /* Fall through. */
9748           case ARRAY_REF:
9749           case INDIRECT_REF:
9750             ctype = NULL_TREE;
9751             innermost_code = TREE_CODE (decl);
9752             next = &TREE_OPERAND (decl, 0);
9753             break;
9754
9755           case CALL_EXPR:
9756             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9757               {
9758                 /* This is actually a variable declaration using
9759                    constructor syntax.  We need to call start_decl and
9760                    cp_finish_decl so we can get the variable
9761                    initialized...  */
9762
9763                 tree attributes, prefix_attributes;
9764
9765                 *next = TREE_OPERAND (decl, 0);
9766                 init = CALL_DECLARATOR_PARMS (decl);
9767
9768                 if (attrlist)
9769                   {
9770                     attributes = TREE_PURPOSE (attrlist);
9771                     prefix_attributes = TREE_VALUE (attrlist);
9772                   }
9773                 else
9774                   {
9775                     attributes = NULL_TREE;
9776                     prefix_attributes = NULL_TREE;
9777                   }
9778
9779                 decl = start_decl (declarator, declspecs, 1,
9780                                    attributes, prefix_attributes);
9781                 decl_type_access_control (decl);
9782                 if (decl)
9783                   {
9784                     /* Look for __unused__ attribute */
9785                     if (TREE_USED (TREE_TYPE (decl)))
9786                       TREE_USED (decl) = 1;
9787                     finish_decl (decl, init, NULL_TREE);
9788                   }
9789                 else
9790                   cp_error ("invalid declarator");
9791                 return 0;
9792               }
9793             innermost_code = TREE_CODE (decl);
9794             if (decl_context == FIELD && ctype == NULL_TREE)
9795               ctype = current_class_type;
9796             if (ctype
9797                 && TREE_OPERAND (decl, 0)
9798                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9799                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9800                          == constructor_name_full (ctype))
9801                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9802                             == constructor_name (ctype)))))
9803               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9804             next = &TREE_OPERAND (decl, 0);
9805             decl = *next;
9806             if (ctype != NULL_TREE
9807                 && decl != NULL_TREE && flags != DTOR_FLAG
9808                 && decl == constructor_name (ctype))
9809               {
9810                 sfk = sfk_constructor;
9811                 ctor_return_type = ctype;
9812               }
9813             ctype = NULL_TREE;
9814             break;
9815
9816           case TEMPLATE_ID_EXPR:
9817               {
9818                 tree fns = TREE_OPERAND (decl, 0);
9819
9820                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9821                   fns = TREE_OPERAND (fns, 0);
9822
9823                 dname = fns;
9824                 if (TREE_CODE (dname) == COMPONENT_REF)
9825                   dname = TREE_OPERAND (dname, 1);
9826                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9827                   {
9828                     my_friendly_assert (is_overloaded_fn (dname),
9829                                         19990331);
9830                     dname = DECL_NAME (get_first_fn (dname));
9831                   }
9832               }
9833           /* Fall through. */
9834
9835           case IDENTIFIER_NODE:
9836             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9837               dname = decl;
9838
9839             next = 0;
9840
9841             if (is_rid (dname))
9842               {
9843                 cp_error ("declarator-id missing; using reserved word `%D'",
9844                           dname);
9845                 name = IDENTIFIER_POINTER (dname);
9846               }
9847             else if (!IDENTIFIER_TYPENAME_P (dname))
9848               name = IDENTIFIER_POINTER (dname);
9849             else
9850               {
9851                 my_friendly_assert (flags == NO_SPECIAL, 154);
9852                 flags = TYPENAME_FLAG;
9853                 ctor_return_type = TREE_TYPE (dname);
9854                 sfk = sfk_conversion;
9855                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9856                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9857                         == TYPE_DECL))
9858                   name = IDENTIFIER_POINTER (dname);
9859                 else
9860                   name = "<invalid operator>";
9861               }
9862             break;
9863
9864             /* C++ extension */
9865           case SCOPE_REF:
9866             {
9867               /* Perform error checking, and decide on a ctype.  */
9868               tree cname = TREE_OPERAND (decl, 0);
9869               if (cname == NULL_TREE)
9870                 ctype = NULL_TREE;
9871               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9872                 {
9873                   ctype = NULL_TREE;
9874                   in_namespace = TREE_OPERAND (decl, 0);
9875                   TREE_OPERAND (decl, 0) = NULL_TREE;
9876                 }
9877               else if (! is_aggr_type (cname, 1))
9878                 TREE_OPERAND (decl, 0) = NULL_TREE;
9879               /* Must test TREE_OPERAND (decl, 1), in case user gives
9880                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9881               else if (TREE_OPERAND (decl, 1)
9882                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9883                 ctype = cname;
9884               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9885                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9886                 {
9887                   cp_error ("`%T::%D' is not a valid declarator", cname,
9888                             TREE_OPERAND (decl, 1));
9889                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9890                             cname, TREE_OPERAND (decl, 1));
9891                   return void_type_node;
9892                 }
9893               else if (ctype == NULL_TREE)
9894                 ctype = cname;
9895               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9896                 TREE_OPERAND (decl, 0) = ctype;
9897               else
9898                 {
9899                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9900                     {
9901                       cp_error ("type `%T' is not derived from type `%T'",
9902                                 cname, ctype);
9903                       TREE_OPERAND (decl, 0) = NULL_TREE;
9904                     }
9905                   else
9906                     ctype = cname;
9907                 }
9908
9909               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9910                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9911                        == constructor_name_full (ctype))
9912                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9913                           == constructor_name (ctype))))
9914                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9915               next = &TREE_OPERAND (decl, 1);
9916               decl = *next;
9917               if (ctype)
9918                 {
9919                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9920                       && constructor_name (ctype) == decl)
9921                     {
9922                       sfk = sfk_constructor;
9923                       ctor_return_type = ctype;
9924                     }
9925                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9926                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9927                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9928                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9929                     {
9930                       sfk = sfk_destructor;
9931                       ctor_return_type = ctype;
9932                       flags = DTOR_FLAG;
9933                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9934                       next = &TREE_OPERAND (decl, 0);
9935                     }
9936                 }
9937             }
9938             break;
9939
9940           case ERROR_MARK:
9941             next = 0;
9942             break;
9943
9944           case TYPE_DECL:
9945             /* Parse error puts this typespec where
9946                a declarator should go.  */
9947             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9948             if (TREE_TYPE (decl) == current_class_type)
9949               cp_error ("  perhaps you want `%T' for a constructor",
9950                         current_class_name);
9951             dname = DECL_NAME (decl);
9952             name = IDENTIFIER_POINTER (dname);
9953
9954             /* Avoid giving two errors for this.  */
9955             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9956
9957             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9958             *next = dname;
9959             next = 0;
9960             break;
9961
9962           default:
9963             cp_compiler_error ("`%D' as declarator", decl);
9964             return 0; /* We used to do a 155 abort here.  */
9965           }
9966       }
9967   }
9968
9969   /* A function definition's declarator must have the form of
9970      a function declarator.  */
9971
9972   if (funcdef_flag && innermost_code != CALL_EXPR)
9973     return 0;
9974
9975   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9976       && innermost_code != CALL_EXPR
9977       && ! (ctype && declspecs == NULL_TREE))
9978     {
9979       cp_error ("declaration of `%D' as non-function", dname);
9980       return void_type_node;
9981     }
9982
9983   /* Anything declared one level down from the top level
9984      must be one of the parameters of a function
9985      (because the body is at least two levels down).  */
9986
9987   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9988      by not allowing C++ class definitions to specify their parameters
9989      with xdecls (must be spec.d in the parmlist).
9990
9991      Since we now wait to push a class scope until we are sure that
9992      we are in a legitimate method context, we must set oldcname
9993      explicitly (since current_class_name is not yet alive).
9994
9995      We also want to avoid calling this a PARM if it is in a namespace.  */
9996
9997   if (decl_context == NORMAL && !toplevel_bindings_p ())
9998     {
9999       struct binding_level *b = current_binding_level;
10000       current_binding_level = b->level_chain;
10001       if (current_binding_level != 0 && toplevel_bindings_p ())
10002         decl_context = PARM;
10003       current_binding_level = b;
10004     }
10005
10006   if (name == NULL)
10007     name = decl_context == PARM ? "parameter" : "type name";
10008
10009   /* Look through the decl specs and record which ones appear.
10010      Some typespecs are defined as built-in typenames.
10011      Others, the ones that are modifiers of other types,
10012      are represented by bits in SPECBITS: set the bits for
10013      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10014
10015      If there is a typedef name or a type, store the type in TYPE.
10016      This includes builtin typedefs such as `int'.
10017
10018      Set EXPLICIT_INT if the type is `int' or `char' and did not
10019      come from a user typedef.
10020
10021      Set LONGLONG if `long' is mentioned twice.
10022
10023      For C++, constructors and destructors have their own fast treatment.  */
10024
10025   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10026     {
10027       register int i;
10028       register tree id;
10029
10030       /* Certain parse errors slip through.  For example,
10031          `int class;' is not caught by the parser. Try
10032          weakly to recover here.  */
10033       if (TREE_CODE (spec) != TREE_LIST)
10034         return 0;
10035
10036       id = TREE_VALUE (spec);
10037
10038       if (TREE_CODE (id) == IDENTIFIER_NODE)
10039         {
10040           if (id == ridpointers[(int) RID_INT]
10041               || id == ridpointers[(int) RID_CHAR]
10042               || id == ridpointers[(int) RID_BOOL]
10043               || id == ridpointers[(int) RID_WCHAR])
10044             {
10045               if (type)
10046                 {
10047                   if (id == ridpointers[(int) RID_BOOL])
10048                     error ("`bool' is now a keyword");
10049                   else
10050                     cp_error ("extraneous `%T' ignored", id);
10051                 }
10052               else
10053                 {
10054                   if (id == ridpointers[(int) RID_INT])
10055                     explicit_int = 1;
10056                   else if (id == ridpointers[(int) RID_CHAR])
10057                     explicit_char = 1;
10058                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10059                 }
10060               goto found;
10061             }
10062           /* C++ aggregate types.  */
10063           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10064             {
10065               if (type)
10066                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10067               else
10068                 type = IDENTIFIER_TYPE_VALUE (id);
10069               goto found;
10070             }
10071
10072           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10073             {
10074               if (ridpointers[i] == id)
10075                 {
10076                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10077                     {
10078                       if (pedantic && ! in_system_header && warn_long_long)
10079                         pedwarn ("ISO C++ does not support `long long'");
10080                       if (longlong)
10081                         error ("`long long long' is too long for GCC");
10082                       else
10083                         longlong = 1;
10084                     }
10085                   else if (RIDBIT_SETP (i, specbits))
10086                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10087                   RIDBIT_SET (i, specbits);
10088                   goto found;
10089                 }
10090             }
10091         }
10092       /* C++ aggregate types.  */
10093       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
10094         {
10095           if (type)
10096             cp_error ("multiple declarations `%T' and `%T'", type,
10097                       TREE_TYPE (id));
10098           else
10099             {
10100               type = TREE_TYPE (id);
10101               TREE_VALUE (spec) = type;
10102             }
10103           goto found;
10104         }
10105       if (type)
10106         error ("two or more data types in declaration of `%s'", name);
10107       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10108         {
10109           register tree t = lookup_name (id, 1);
10110           if (!t || TREE_CODE (t) != TYPE_DECL)
10111             error ("`%s' fails to be a typedef or built in type",
10112                    IDENTIFIER_POINTER (id));
10113           else
10114             {
10115               type = TREE_TYPE (t);
10116 #if 0
10117               /* See the code below that used this.  */
10118               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10119 #endif
10120               typedef_decl = t;
10121             }
10122         }
10123       else if (id != error_mark_node)
10124         /* Can't change CLASS nodes into RECORD nodes here!  */
10125         type = id;
10126
10127     found: ;
10128     }
10129
10130   typedef_type = type;
10131
10132   /* No type at all: default to `int', and set DEFAULTED_INT
10133      because it was not a user-defined typedef.  */
10134
10135   if (type == NULL_TREE
10136       && (RIDBIT_SETP (RID_SIGNED, specbits)
10137           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10138           || RIDBIT_SETP (RID_LONG, specbits)
10139           || RIDBIT_SETP (RID_SHORT, specbits)))
10140     {
10141       /* These imply 'int'.  */
10142       type = integer_type_node;
10143       defaulted_int = 1;
10144     }
10145
10146   if (sfk != sfk_none)
10147     type = check_special_function_return_type (sfk, type,
10148                                                ctor_return_type,
10149                                                ctor_return_type);
10150   else if (type == NULL_TREE)
10151     {
10152       int is_main;
10153
10154       explicit_int = -1;
10155
10156           /* We handle `main' specially here, because 'main () { }' is so
10157              common.  With no options, it is allowed.  With -Wreturn-type,
10158              it is a warning.  It is only an error with -pedantic-errors.  */
10159       is_main = (funcdef_flag
10160                  && MAIN_NAME_P (dname)
10161                  && ctype == NULL_TREE
10162                  && in_namespace == NULL_TREE
10163                  && current_namespace == global_namespace);
10164
10165       if (in_system_header || flag_ms_extensions)
10166         /* Allow it, sigh.  */;
10167       else if (pedantic || ! is_main)
10168         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10169                     name);
10170       else if (warn_return_type)
10171         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10172                     name);
10173
10174       type = integer_type_node;
10175     }
10176
10177   ctype = NULL_TREE;
10178
10179   /* Now process the modifiers that were specified
10180      and check for invalid combinations.  */
10181
10182   /* Long double is a special combination.  */
10183
10184   if (RIDBIT_SETP (RID_LONG, specbits)
10185       && TYPE_MAIN_VARIANT (type) == double_type_node)
10186     {
10187       RIDBIT_RESET (RID_LONG, specbits);
10188       type = build_qualified_type (long_double_type_node,
10189                                    CP_TYPE_QUALS (type));
10190     }
10191
10192   /* Check all other uses of type modifiers.  */
10193
10194   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10195       || RIDBIT_SETP (RID_SIGNED, specbits)
10196       || RIDBIT_SETP (RID_LONG, specbits)
10197       || RIDBIT_SETP (RID_SHORT, specbits))
10198     {
10199       int ok = 0;
10200
10201       if (TREE_CODE (type) == REAL_TYPE)
10202         error ("short, signed or unsigned invalid for `%s'", name);
10203       else if (TREE_CODE (type) != INTEGER_TYPE)
10204         error ("long, short, signed or unsigned invalid for `%s'", name);
10205       else if (RIDBIT_SETP (RID_LONG, specbits)
10206                && RIDBIT_SETP (RID_SHORT, specbits))
10207         error ("long and short specified together for `%s'", name);
10208       else if ((RIDBIT_SETP (RID_LONG, specbits)
10209                 || RIDBIT_SETP (RID_SHORT, specbits))
10210                && explicit_char)
10211         error ("long or short specified with char for `%s'", name);
10212       else if ((RIDBIT_SETP (RID_LONG, specbits)
10213                 || RIDBIT_SETP (RID_SHORT, specbits))
10214                && TREE_CODE (type) == REAL_TYPE)
10215         error ("long or short specified with floating type for `%s'", name);
10216       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10217                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10218         error ("signed and unsigned given together for `%s'", name);
10219       else
10220         {
10221           ok = 1;
10222           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10223             {
10224               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10225                        name);
10226               if (flag_pedantic_errors)
10227                 ok = 0;
10228             }
10229         }
10230
10231       /* Discard the type modifiers if they are invalid.  */
10232       if (! ok)
10233         {
10234           RIDBIT_RESET (RID_UNSIGNED, specbits);
10235           RIDBIT_RESET (RID_SIGNED, specbits);
10236           RIDBIT_RESET (RID_LONG, specbits);
10237           RIDBIT_RESET (RID_SHORT, specbits);
10238           longlong = 0;
10239         }
10240     }
10241
10242   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10243       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10244     {
10245       error ("complex invalid for `%s'", name);
10246       RIDBIT_RESET (RID_COMPLEX, specbits);
10247     }
10248
10249   /* Decide whether an integer type is signed or not.
10250      Optionally treat bitfields as signed by default.  */
10251   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10252       /* [class.bit]
10253
10254          It is implementation-defined whether a plain (neither
10255          explicitly signed or unsigned) char, short, int, or long
10256          bit-field is signed or unsigned.
10257
10258          Naturally, we extend this to long long as well.  Note that
10259          this does not include wchar_t.  */
10260       || (bitfield && !flag_signed_bitfields
10261           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10262           /* A typedef for plain `int' without `signed' can be
10263              controlled just like plain `int', but a typedef for
10264              `signed int' cannot be so controlled.  */
10265           && !(typedef_decl
10266                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10267           && (TREE_CODE (type) == INTEGER_TYPE
10268               || TREE_CODE (type) == CHAR_TYPE)
10269           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10270     {
10271       if (longlong)
10272         type = long_long_unsigned_type_node;
10273       else if (RIDBIT_SETP (RID_LONG, specbits))
10274         type = long_unsigned_type_node;
10275       else if (RIDBIT_SETP (RID_SHORT, specbits))
10276         type = short_unsigned_type_node;
10277       else if (type == char_type_node)
10278         type = unsigned_char_type_node;
10279       else if (typedef_decl)
10280         type = unsigned_type (type);
10281       else
10282         type = unsigned_type_node;
10283     }
10284   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10285            && type == char_type_node)
10286     type = signed_char_type_node;
10287   else if (longlong)
10288     type = long_long_integer_type_node;
10289   else if (RIDBIT_SETP (RID_LONG, specbits))
10290     type = long_integer_type_node;
10291   else if (RIDBIT_SETP (RID_SHORT, specbits))
10292     type = short_integer_type_node;
10293
10294   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10295     {
10296       /* If we just have "complex", it is equivalent to
10297          "complex double", but if any modifiers at all are specified it is
10298          the complex form of TYPE.  E.g, "complex short" is
10299          "complex short int".  */
10300
10301       if (defaulted_int && ! longlong
10302           && ! (RIDBIT_SETP (RID_LONG, specbits)
10303                 || RIDBIT_SETP (RID_SHORT, specbits)
10304                 || RIDBIT_SETP (RID_SIGNED, specbits)
10305                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10306         type = complex_double_type_node;
10307       else if (type == integer_type_node)
10308         type = complex_integer_type_node;
10309       else if (type == float_type_node)
10310         type = complex_float_type_node;
10311       else if (type == double_type_node)
10312         type = complex_double_type_node;
10313       else if (type == long_double_type_node)
10314         type = complex_long_double_type_node;
10315       else
10316         type = build_complex_type (type);
10317     }
10318
10319   if (sfk == sfk_conversion
10320       && (RIDBIT_SETP (RID_CONST, specbits)
10321           || RIDBIT_SETP (RID_VOLATILE, specbits)
10322           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10323     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10324               ctor_return_type);
10325
10326   /* Set CONSTP if this declaration is `const', whether by
10327      explicit specification or via a typedef.
10328      Likewise for VOLATILEP.  */
10329
10330   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10331   restrictp =
10332     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10333   volatilep =
10334     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10335   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10336                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10337                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10338   type = cp_build_qualified_type (type, type_quals);
10339   staticp = 0;
10340   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10341   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10342   RIDBIT_RESET (RID_VIRTUAL, specbits);
10343   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10344   RIDBIT_RESET (RID_EXPLICIT, specbits);
10345
10346   if (RIDBIT_SETP (RID_STATIC, specbits))
10347     staticp = 1 + (decl_context == FIELD);
10348
10349   if (virtualp && staticp == 2)
10350     {
10351       cp_error ("member `%D' cannot be declared both virtual and static",
10352                 dname);
10353       staticp = 0;
10354     }
10355   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10356   RIDBIT_RESET (RID_FRIEND, specbits);
10357
10358   /* Warn if two storage classes are given. Default to `auto'.  */
10359
10360   if (RIDBIT_ANY_SET (specbits))
10361     {
10362       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10363       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10364       if (decl_context == PARM && nclasses > 0)
10365         error ("storage class specifiers invalid in parameter declarations");
10366       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10367         {
10368           if (decl_context == PARM)
10369             error ("typedef declaration invalid in parameter declaration");
10370           nclasses++;
10371         }
10372       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10373       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10374     }
10375
10376   /* Give error if `virtual' is used outside of class declaration.  */
10377   if (virtualp
10378       && (current_class_name == NULL_TREE || decl_context != FIELD))
10379     {
10380       error ("virtual outside class declaration");
10381       virtualp = 0;
10382     }
10383
10384   /* Static anonymous unions are dealt with here.  */
10385   if (staticp && decl_context == TYPENAME
10386       && TREE_CODE (declspecs) == TREE_LIST
10387       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10388     decl_context = FIELD;
10389
10390   /* Warn about storage classes that are invalid for certain
10391      kinds of declarations (parameters, typenames, etc.).  */
10392
10393   if (nclasses > 1)
10394     error ("multiple storage classes in declaration of `%s'", name);
10395   else if (decl_context != NORMAL && nclasses > 0)
10396     {
10397       if ((decl_context == PARM || decl_context == CATCHPARM)
10398           && (RIDBIT_SETP (RID_REGISTER, specbits)
10399               || RIDBIT_SETP (RID_AUTO, specbits)))
10400         ;
10401       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10402         ;
10403       else if (decl_context == FIELD
10404                /* C++ allows static class elements  */
10405                && RIDBIT_SETP (RID_STATIC, specbits))
10406         /* C++ also allows inlines and signed and unsigned elements,
10407            but in those cases we don't come in here.  */
10408         ;
10409       else
10410         {
10411           if (decl_context == FIELD)
10412             {
10413               tree tmp = NULL_TREE;
10414               register int op = 0;
10415
10416               if (declarator)
10417                 {
10418                   /* Avoid trying to get an operand off an identifier node.  */
10419                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10420                     tmp = declarator;
10421                   else
10422                     tmp = TREE_OPERAND (declarator, 0);
10423                   op = IDENTIFIER_OPNAME_P (tmp);
10424                   if (IDENTIFIER_TYPENAME_P (tmp))
10425                     {
10426                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10427                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10428                               == TYPE_DECL))
10429                         name = IDENTIFIER_POINTER (tmp);
10430                       else
10431                         name = "<invalid operator>";
10432                     }
10433                 }
10434               error ("storage class specified for %s `%s'",
10435                      op ? "member operator" : "field",
10436                      name);
10437             }
10438           else
10439             {
10440               if (decl_context == PARM || decl_context == CATCHPARM)
10441                 error ("storage class specified for parameter `%s'", name);
10442               else
10443                 error ("storage class specified for typename");
10444             }
10445           RIDBIT_RESET (RID_REGISTER, specbits);
10446           RIDBIT_RESET (RID_AUTO, specbits);
10447           RIDBIT_RESET (RID_EXTERN, specbits);
10448         }
10449     }
10450   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10451     {
10452       if (toplevel_bindings_p ())
10453         {
10454           /* It's common practice (and completely valid) to have a const
10455              be initialized and declared extern.  */
10456           if (!(type_quals & TYPE_QUAL_CONST))
10457             warning ("`%s' initialized and declared `extern'", name);
10458         }
10459       else
10460         error ("`%s' has both `extern' and initializer", name);
10461     }
10462   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10463            && ! toplevel_bindings_p ())
10464     error ("nested function `%s' declared `extern'", name);
10465   else if (toplevel_bindings_p ())
10466     {
10467       if (RIDBIT_SETP (RID_AUTO, specbits))
10468         error ("top-level declaration of `%s' specifies `auto'", name);
10469     }
10470
10471   if (nclasses > 0 && friendp)
10472     error ("storage class specifiers invalid in friend function declarations");
10473
10474   /* Now figure out the structure of the declarator proper.
10475      Descend through it, creating more complex types, until we reach
10476      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10477
10478   inner_attrs = NULL_TREE;
10479   ignore_attrs = 0;
10480
10481   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10482          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10483     {
10484       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10485          an INDIRECT_REF (for *...),
10486          a CALL_EXPR (for ...(...)),
10487          an identifier (for the name being declared)
10488          or a null pointer (for the place in an absolute declarator
10489          where the name was omitted).
10490          For the last two cases, we have just exited the loop.
10491
10492          For C++ it could also be
10493          a SCOPE_REF (for class :: ...).  In this case, we have converted
10494          sensible names to types, and those are the values we use to
10495          qualify the member name.
10496          an ADDR_EXPR (for &...),
10497          a BIT_NOT_EXPR (for destructors)
10498
10499          At this point, TYPE is the type of elements of an array,
10500          or for a function to return, or for a pointer to point to.
10501          After this sequence of ifs, TYPE is the type of the
10502          array or function or pointer, and DECLARATOR has had its
10503          outermost layer removed.  */
10504
10505       if (type == error_mark_node)
10506         {
10507           if (TREE_CODE (declarator) == SCOPE_REF)
10508             declarator = TREE_OPERAND (declarator, 1);
10509           else
10510             declarator = TREE_OPERAND (declarator, 0);
10511           continue;
10512         }
10513       if (quals != NULL_TREE
10514           && (declarator == NULL_TREE
10515               || TREE_CODE (declarator) != SCOPE_REF))
10516         {
10517           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10518             ctype = TYPE_METHOD_BASETYPE (type);
10519           if (ctype != NULL_TREE)
10520             {
10521               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10522               grok_method_quals (ctype, dummy, quals);
10523               type = TREE_TYPE (dummy);
10524               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10525               quals = NULL_TREE;
10526             }
10527         }
10528
10529       /* See the comment for the TREE_LIST case, below.  */
10530       if (ignore_attrs)
10531         ignore_attrs = 0;
10532       else if (inner_attrs)
10533         {
10534           decl_attributes (type, inner_attrs, NULL_TREE);
10535           inner_attrs = NULL_TREE;
10536         }
10537
10538       switch (TREE_CODE (declarator))
10539         {
10540         case TREE_LIST:
10541           {
10542             /* We encode a declarator with embedded attributes using
10543                a TREE_LIST.  The attributes apply to the declarator
10544                directly inside them, so we have to skip an iteration
10545                before applying them to the type.  If the declarator just
10546                inside is the declarator-id, we apply the attrs to the
10547                decl itself.  */
10548             inner_attrs = TREE_PURPOSE (declarator);
10549             ignore_attrs = 1;
10550             declarator = TREE_VALUE (declarator);
10551           }
10552           break;
10553
10554         case ARRAY_REF:
10555           {
10556             register tree size;
10557
10558             size = TREE_OPERAND (declarator, 1);
10559
10560             /* VC++ spells a zero-sized array with [].  */
10561             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10562                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10563               size = integer_zero_node;
10564
10565             declarator = TREE_OPERAND (declarator, 0);
10566
10567             type = create_array_type_for_decl (dname, type, size);
10568
10569             /* VLAs never work as fields. */
10570             if (decl_context == FIELD && !processing_template_decl
10571                 && TREE_CODE (type) == ARRAY_TYPE
10572                 && TYPE_DOMAIN (type) != NULL_TREE
10573                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10574               {
10575                 cp_error ("size of member `%D' is not constant", dname);
10576                 /* Proceed with arbitrary constant size, so that offset
10577                    computations don't get confused. */
10578                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10579                                                    integer_one_node);
10580               }
10581
10582             ctype = NULL_TREE;
10583           }
10584           break;
10585
10586         case CALL_EXPR:
10587           {
10588             tree arg_types;
10589             int funcdecl_p;
10590             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10591             tree inner_decl = TREE_OPERAND (declarator, 0);
10592
10593             /* Declaring a function type.
10594                Make sure we have a valid type for the function to return.  */
10595
10596             /* We now know that the TYPE_QUALS don't apply to the
10597                decl, but to its return type.  */
10598             type_quals = TYPE_UNQUALIFIED;
10599
10600             /* Warn about some types functions can't return.  */
10601
10602             if (TREE_CODE (type) == FUNCTION_TYPE)
10603               {
10604                 error ("`%s' declared as function returning a function", name);
10605                 type = integer_type_node;
10606               }
10607             if (TREE_CODE (type) == ARRAY_TYPE)
10608               {
10609                 error ("`%s' declared as function returning an array", name);
10610                 type = integer_type_node;
10611               }
10612
10613             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10614               inner_decl = TREE_OPERAND (inner_decl, 1);
10615
10616             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10617               inner_decl = dname;
10618
10619             /* Pick up type qualifiers which should be applied to `this'.  */
10620             quals = CALL_DECLARATOR_QUALS (declarator);
10621
10622             /* Pick up the exception specifications.  */
10623             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10624
10625             /* Say it's a definition only for the CALL_EXPR
10626                closest to the identifier.  */
10627             funcdecl_p
10628               = inner_decl
10629               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10630                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10631                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10632
10633             if (ctype == NULL_TREE
10634                 && decl_context == FIELD
10635                 && funcdecl_p
10636                 && (friendp == 0 || dname == current_class_name))
10637               ctype = current_class_type;
10638
10639             if (ctype && sfk == sfk_conversion)
10640               TYPE_HAS_CONVERSION (ctype) = 1;
10641             if (ctype && constructor_name (ctype) == dname)
10642               {
10643                 /* We are within a class's scope. If our declarator name
10644                    is the same as the class name, and we are defining
10645                    a function, then it is a constructor/destructor, and
10646                    therefore returns a void type.  */
10647
10648                 if (flags == DTOR_FLAG)
10649                   {
10650                     /* ISO C++ 12.4/2.  A destructor may not be
10651                        declared const or volatile.  A destructor may
10652                        not be static.  */
10653                     if (staticp == 2)
10654                       error ("destructor cannot be static member function");
10655                     if (quals)
10656                       {
10657                         cp_error ("destructors may not be `%s'",
10658                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10659                         quals = NULL_TREE;
10660                       }
10661                     if (decl_context == FIELD)
10662                       {
10663                         if (! member_function_or_else (ctype,
10664                                                        current_class_type,
10665                                                        flags))
10666                           return void_type_node;
10667                       }
10668                   }
10669                 else            /* It's a constructor.  */
10670                   {
10671                     if (explicitp == 1)
10672                       explicitp = 2;
10673                     /* ISO C++ 12.1.  A constructor may not be
10674                        declared const or volatile.  A constructor may
10675                        not be virtual.  A constructor may not be
10676                        static.  */
10677                     if (staticp == 2)
10678                       error ("constructor cannot be static member function");
10679                     if (virtualp)
10680                       {
10681                         pedwarn ("constructors cannot be declared virtual");
10682                         virtualp = 0;
10683                       }
10684                     if (quals)
10685                       {
10686                         cp_error ("constructors may not be `%s'",
10687                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10688                         quals = NULL_TREE;
10689                       }
10690                     {
10691                       RID_BIT_TYPE tmp_bits;
10692                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10693                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10694                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10695                       if (RIDBIT_ANY_SET (tmp_bits))
10696                         error ("return value type specifier for constructor ignored");
10697                     }
10698                     if (decl_context == FIELD)
10699                       {
10700                         if (! member_function_or_else (ctype,
10701                                                        current_class_type,
10702                                                        flags))
10703                           return void_type_node;
10704                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10705                         if (sfk != sfk_constructor)
10706                           return NULL_TREE;
10707                       }
10708                   }
10709                 if (decl_context == FIELD)
10710                   staticp = 0;
10711               }
10712             else if (friendp)
10713               {
10714                 if (initialized)
10715                   error ("can't initialize friend function `%s'", name);
10716                 if (virtualp)
10717                   {
10718                     /* Cannot be both friend and virtual.  */
10719                     error ("virtual functions cannot be friends");
10720                     RIDBIT_RESET (RID_FRIEND, specbits);
10721                     friendp = 0;
10722                   }
10723                 if (decl_context == NORMAL)
10724                   error ("friend declaration not in class definition");
10725                 if (current_function_decl && funcdef_flag)
10726                   cp_error ("can't define friend function `%s' in a local class definition",
10727                             name);
10728               }
10729
10730             /* Construct the function type and go to the next
10731                inner layer of declarator.  */
10732
10733             declarator = TREE_OPERAND (declarator, 0);
10734
10735             /* FIXME: This is where default args should be fully
10736                processed.  */
10737
10738             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10739
10740             if (declarator && flags == DTOR_FLAG)
10741               {
10742                 /* A destructor declared in the body of a class will
10743                    be represented as a BIT_NOT_EXPR.  But, we just
10744                    want the underlying IDENTIFIER.  */
10745                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10746                   declarator = TREE_OPERAND (declarator, 0);
10747
10748                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10749                   arg_types = void_list_node;
10750                 else if (arg_types == NULL_TREE
10751                          || arg_types != void_list_node)
10752                   {
10753                     cp_error ("destructors may not have parameters");
10754                     arg_types = void_list_node;
10755                     last_function_parms = NULL_TREE;
10756                   }
10757               }
10758
10759             /* ANSI says that `const int foo ();'
10760                does not make the function foo const.  */
10761             type = build_function_type (type, arg_types);
10762
10763             {
10764               tree t;
10765               for (t = arg_types; t; t = TREE_CHAIN (t))
10766                 if (TREE_PURPOSE (t)
10767                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10768                   {
10769                     add_defarg_fn (type);
10770                     break;
10771                   }
10772             }
10773           }
10774           break;
10775
10776         case ADDR_EXPR:
10777         case INDIRECT_REF:
10778           /* Filter out pointers-to-references and references-to-references.
10779              We can get these if a TYPE_DECL is used.  */
10780
10781           if (TREE_CODE (type) == REFERENCE_TYPE)
10782             {
10783               error ("cannot declare %s to references",
10784                      TREE_CODE (declarator) == ADDR_EXPR
10785                      ? "references" : "pointers");
10786               declarator = TREE_OPERAND (declarator, 0);
10787               continue;
10788             }
10789
10790           if (TREE_CODE (type) == OFFSET_TYPE
10791               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10792                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10793             {
10794               cp_error ("cannot declare pointer to `%#T' member",
10795                         TREE_TYPE (type));
10796               type = TREE_TYPE (type);
10797             }
10798
10799           /* Merge any constancy or volatility into the target type
10800              for the pointer.  */
10801
10802           /* We now know that the TYPE_QUALS don't apply to the decl,
10803              but to the target of the pointer.  */
10804           type_quals = TYPE_UNQUALIFIED;
10805
10806           if (TREE_CODE (declarator) == ADDR_EXPR)
10807             {
10808               if (TREE_CODE (type) == VOID_TYPE)
10809                 error ("invalid type: `void &'");
10810               else
10811                 type = build_reference_type (type);
10812             }
10813           else if (TREE_CODE (type) == METHOD_TYPE)
10814             type = build_ptrmemfunc_type (build_pointer_type (type));
10815           else
10816             type = build_pointer_type (type);
10817
10818           /* Process a list of type modifier keywords (such as
10819              const or volatile) that were given inside the `*' or `&'.  */
10820
10821           if (TREE_TYPE (declarator))
10822             {
10823               register tree typemodlist;
10824               int erred = 0;
10825
10826               constp = 0;
10827               volatilep = 0;
10828               restrictp = 0;
10829               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10830                    typemodlist = TREE_CHAIN (typemodlist))
10831                 {
10832                   tree qualifier = TREE_VALUE (typemodlist);
10833
10834                   if (qualifier == ridpointers[(int) RID_CONST])
10835                     constp++;
10836                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10837                     volatilep++;
10838                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10839                     restrictp++;
10840                   else if (!erred)
10841                     {
10842                       erred = 1;
10843                       error ("invalid type modifier within pointer declarator");
10844                     }
10845                 }
10846               if (constp > 1)
10847                 pedwarn ("duplicate `const'");
10848               if (volatilep > 1)
10849                 pedwarn ("duplicate `volatile'");
10850               if (restrictp > 1)
10851                 pedwarn ("duplicate `restrict'");
10852
10853               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10854                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10855                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10856               if (TREE_CODE (declarator) == ADDR_EXPR
10857                   && (constp || volatilep))
10858                 {
10859                   if (constp)
10860                     pedwarn ("discarding `const' applied to a reference");
10861                   if (volatilep)
10862                     pedwarn ("discarding `volatile' applied to a reference");
10863                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10864                 }
10865               type = cp_build_qualified_type (type, type_quals);
10866             }
10867           declarator = TREE_OPERAND (declarator, 0);
10868           ctype = NULL_TREE;
10869           break;
10870
10871         case SCOPE_REF:
10872           {
10873             /* We have converted type names to NULL_TREE if the
10874                name was bogus, or to a _TYPE node, if not.
10875
10876                The variable CTYPE holds the type we will ultimately
10877                resolve to.  The code here just needs to build
10878                up appropriate member types.  */
10879             tree sname = TREE_OPERAND (declarator, 1);
10880             tree t;
10881
10882             /* Destructors can have their visibilities changed as well.  */
10883             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10884               sname = TREE_OPERAND (sname, 0);
10885
10886             if (TREE_COMPLEXITY (declarator) == 0)
10887               /* This needs to be here, in case we are called
10888                  multiple times.  */ ;
10889             else if (TREE_COMPLEXITY (declarator) == -1)
10890               /* Namespace member. */
10891               pop_decl_namespace ();
10892             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10893               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10894             else if (! IS_AGGR_TYPE_CODE
10895                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10896               ;
10897             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10898               {
10899                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10900                    that refer to ctype.  They couldn't be resolved earlier
10901                    because we hadn't pushed into the class yet.
10902                    Example: resolve 'B<T>::type' in
10903                    'B<typename B<T>::type> B<T>::f () { }'.  */
10904                 if (current_template_parms
10905                     && uses_template_parms (type)
10906                     && uses_template_parms (current_class_type))
10907                   {
10908                     tree args = current_template_args ();
10909                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10910                   }
10911
10912                 /* This pop_nested_class corresponds to the
10913                    push_nested_class used to push into class scope for
10914                    parsing the argument list of a function decl, in
10915                    qualified_id.  */
10916                 pop_nested_class ();
10917                 TREE_COMPLEXITY (declarator) = current_class_depth;
10918               }
10919             else
10920               my_friendly_abort (16);
10921
10922             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10923               {
10924                 /* We had a reference to a global decl, or
10925                    perhaps we were given a non-aggregate typedef,
10926                    in which case we cleared this out, and should just
10927                    keep going as though it wasn't there.  */
10928                 declarator = sname;
10929                 continue;
10930               }
10931             ctype = TREE_OPERAND (declarator, 0);
10932
10933             t = ctype;
10934             while (t != NULL_TREE && CLASS_TYPE_P (t))
10935               {
10936                 /* You're supposed to have one `template <...>'
10937                    for every template class, but you don't need one
10938                    for a full specialization.  For example:
10939
10940                      template <class T> struct S{};
10941                      template <> struct S<int> { void f(); };
10942                      void S<int>::f () {}
10943
10944                    is correct; there shouldn't be a `template <>' for
10945                    the definition of `S<int>::f'.  */
10946                 if (CLASSTYPE_TEMPLATE_INFO (t)
10947                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10948                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10949                   template_count += 1;
10950
10951                 t = TYPE_MAIN_DECL (t);
10952                 if (DECL_LANG_SPECIFIC (t))
10953                   t = DECL_CONTEXT (t);
10954                 else
10955                   t = NULL_TREE;
10956               }
10957
10958             if (sname == NULL_TREE)
10959               goto done_scoping;
10960
10961             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10962               {
10963                 /* This is the `standard' use of the scoping operator:
10964                    basetype :: member .  */
10965
10966                 if (ctype == current_class_type)
10967                   {
10968                     /* class A {
10969                          void A::f ();
10970                        };
10971
10972                        Is this ill-formed?  */
10973
10974                     if (pedantic)
10975                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10976                                   ctype, name);
10977                   }
10978                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10979                   {
10980                     if (current_class_type == NULL_TREE
10981                         || friendp)
10982                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10983                                                       TYPE_ARG_TYPES (type));
10984                     else
10985                       {
10986                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10987                                   ctype, name, current_class_type);
10988                         return void_type_node;
10989                       }
10990                   }
10991                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10992                          || COMPLETE_TYPE_P (complete_type (ctype)))
10993                   {
10994                     /* Have to move this code elsewhere in this function.
10995                        this code is used for i.e., typedef int A::M; M *pm;
10996
10997                        It is?  How? jason 10/2/94 */
10998
10999                     if (current_class_type)
11000                       {
11001                         cp_error ("cannot declare member `%T::%s' within `%T'",
11002                                   ctype, name, current_class_type);
11003                         return void_type_node;
11004                       }
11005                     type = build_offset_type (ctype, type);
11006                   }
11007                 else if (uses_template_parms (ctype))
11008                   {
11009                     if (TREE_CODE (type) == FUNCTION_TYPE)
11010                       type
11011                         = build_cplus_method_type (ctype, TREE_TYPE (type),
11012                                                    TYPE_ARG_TYPES (type));
11013                   }
11014                 else
11015                   {
11016                     cp_error ("structure `%T' not yet defined", ctype);
11017                     return error_mark_node;
11018                   }
11019
11020                 declarator = sname;
11021               }
11022             else if (TREE_CODE (sname) == SCOPE_REF)
11023               my_friendly_abort (17);
11024             else
11025               {
11026               done_scoping:
11027                 declarator = TREE_OPERAND (declarator, 1);
11028                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11029                   /* In this case, we will deal with it later.  */
11030                   ;
11031                 else
11032                   {
11033                     if (TREE_CODE (type) == FUNCTION_TYPE)
11034                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11035                                                       TYPE_ARG_TYPES (type));
11036                     else
11037                       type = build_offset_type (ctype, type);
11038                   }
11039               }
11040           }
11041           break;
11042
11043         case BIT_NOT_EXPR:
11044           declarator = TREE_OPERAND (declarator, 0);
11045           break;
11046
11047         case RECORD_TYPE:
11048         case UNION_TYPE:
11049         case ENUMERAL_TYPE:
11050           declarator = NULL_TREE;
11051           break;
11052
11053         case ERROR_MARK:
11054           declarator = NULL_TREE;
11055           break;
11056
11057         default:
11058           my_friendly_abort (158);
11059         }
11060     }
11061
11062   /* See the comment for the TREE_LIST case, above.  */
11063   if (inner_attrs)
11064     {
11065       if (! ignore_attrs)
11066         decl_attributes (type, inner_attrs, NULL_TREE);
11067       else if (attrlist)
11068         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11069       else
11070         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11071     }
11072
11073   /* Now TYPE has the actual type.  */
11074
11075   if (explicitp == 1 || (explicitp && friendp))
11076     {
11077       /* [dcl.fct.spec] The explicit specifier shall only be used in
11078          declarations of constructors within a class definition.  */
11079       error ("only declarations of constructors can be `explicit'");
11080       explicitp = 0;
11081     }
11082
11083   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11084     {
11085       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11086         {
11087           error ("non-member `%s' cannot be declared `mutable'", name);
11088           RIDBIT_RESET (RID_MUTABLE, specbits);
11089         }
11090       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11091         {
11092           error ("non-object member `%s' cannot be declared `mutable'", name);
11093           RIDBIT_RESET (RID_MUTABLE, specbits);
11094         }
11095       else if (TREE_CODE (type) == FUNCTION_TYPE
11096                || TREE_CODE (type) == METHOD_TYPE)
11097         {
11098           error ("function `%s' cannot be declared `mutable'", name);
11099           RIDBIT_RESET (RID_MUTABLE, specbits);
11100         }
11101       else if (staticp)
11102         {
11103           error ("static `%s' cannot be declared `mutable'", name);
11104           RIDBIT_RESET (RID_MUTABLE, specbits);
11105         }
11106       else if (type_quals & TYPE_QUAL_CONST)
11107         {
11108           error ("const `%s' cannot be declared `mutable'", name);
11109           RIDBIT_RESET (RID_MUTABLE, specbits);
11110         }
11111     }
11112
11113   if (declarator == NULL_TREE
11114       || TREE_CODE (declarator) == IDENTIFIER_NODE
11115       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11116           && (TREE_CODE (type) == FUNCTION_TYPE
11117               || TREE_CODE (type) == METHOD_TYPE)))
11118     /* OK */;
11119   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11120     {
11121       cp_error ("template-id `%D' used as a declarator", declarator);
11122       declarator = dname;
11123     }
11124   else
11125     /* Unexpected declarator format.  */
11126     my_friendly_abort (990210);
11127
11128   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11129
11130   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11131     {
11132       tree decl;
11133
11134       /* Note that the grammar rejects storage classes
11135          in typenames, fields or parameters.  */
11136       if (current_lang_name == lang_name_java)
11137         TYPE_FOR_JAVA (type) = 1;
11138
11139       if (decl_context == FIELD)
11140         {
11141           if (declarator == constructor_name (current_class_type))
11142             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11143                         declarator);
11144           decl = build_lang_decl (TYPE_DECL, declarator, type);
11145         }
11146       else
11147         decl = build_decl (TYPE_DECL, declarator, type);
11148
11149       /* If the user declares "typedef struct {...} foo" then the
11150          struct will have an anonymous name.  Fill that name in now.
11151          Nothing can refer to it, so nothing needs know about the name
11152          change.  */
11153       if (type != error_mark_node
11154           && declarator
11155           && TYPE_NAME (type)
11156           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11157           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11158           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11159         {
11160           tree oldname = TYPE_NAME (type);
11161           tree t;
11162
11163           /* Replace the anonymous name with the real name everywhere.  */
11164           lookup_tag_reverse (type, declarator);
11165           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11166             if (TYPE_NAME (t) == oldname)
11167               TYPE_NAME (t) = decl;
11168
11169           if (TYPE_LANG_SPECIFIC (type))
11170             TYPE_WAS_ANONYMOUS (type) = 1;
11171
11172           /* If this is a typedef within a template class, the nested
11173              type is a (non-primary) template.  The name for the
11174              template needs updating as well.  */
11175           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11176             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11177               = TYPE_IDENTIFIER (type);
11178
11179           if (flag_new_abi)
11180             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11181           else
11182             {
11183               /* XXX Temporarily set the scope.
11184                  When returning, start_decl expects it as NULL_TREE,
11185                  and will then then set it using pushdecl. */
11186               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11187               if (current_class_type)
11188                 DECL_CONTEXT (decl) = current_class_type;
11189               else
11190                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11191
11192               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11193               DECL_ASSEMBLER_NAME (decl)
11194                 = get_identifier (build_overload_name (type, 1, 1));
11195               DECL_CONTEXT (decl) = NULL_TREE;
11196             }
11197
11198           /* FIXME remangle member functions; member functions of a
11199              type with external linkage have external linkage.  */
11200         }
11201
11202       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11203         {
11204           cp_error_at ("typedef name may not be class-qualified", decl);
11205           return NULL_TREE;
11206         }
11207       else if (quals)
11208         {
11209           if (ctype == NULL_TREE)
11210             {
11211               if (TREE_CODE (type) != METHOD_TYPE)
11212                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11213               else
11214                 ctype = TYPE_METHOD_BASETYPE (type);
11215             }
11216           if (ctype != NULL_TREE)
11217             grok_method_quals (ctype, decl, quals);
11218         }
11219
11220       if (RIDBIT_SETP (RID_SIGNED, specbits)
11221           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11222         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11223
11224       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11225                       inlinep, friendp, raises != NULL_TREE);
11226
11227       if (initialized)
11228         error ("typedef declaration includes an initializer");
11229
11230       return decl;
11231     }
11232
11233   /* Detect the case of an array type of unspecified size
11234      which came, as such, direct from a typedef name.
11235      We must copy the type, so that each identifier gets
11236      a distinct type, so that each identifier's size can be
11237      controlled separately by its own initializer.  */
11238
11239   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11240       && TYPE_DOMAIN (type) == NULL_TREE)
11241     {
11242       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11243     }
11244
11245   /* If this is a type name (such as, in a cast or sizeof),
11246      compute the type and return it now.  */
11247
11248   if (decl_context == TYPENAME)
11249     {
11250       /* Note that the grammar rejects storage classes
11251          in typenames, fields or parameters.  */
11252       if (type_quals != TYPE_UNQUALIFIED)
11253         type_quals = TYPE_UNQUALIFIED;
11254
11255       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11256       if (friendp)
11257         {
11258           if (type_quals != TYPE_UNQUALIFIED)
11259             {
11260               cp_error ("type qualifiers specified for friend class declaration");
11261               type_quals = TYPE_UNQUALIFIED;
11262             }
11263           if (inlinep)
11264             {
11265               cp_error ("`inline' specified for friend class declaration");
11266               inlinep = 0;
11267             }
11268
11269           /* Only try to do this stuff if we didn't already give up.  */
11270           if (type != integer_type_node)
11271             {
11272               /* A friendly class?  */
11273               if (current_class_type)
11274                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11275               else
11276                 error ("trying to make class `%s' a friend of global scope",
11277                        TYPE_NAME_STRING (type));
11278               type = void_type_node;
11279             }
11280         }
11281       else if (quals)
11282         {
11283           if (ctype == NULL_TREE)
11284             {
11285               if (TREE_CODE (type) != METHOD_TYPE)
11286                 cp_error ("invalid qualifiers on non-member function type");
11287               else
11288                 ctype = TYPE_METHOD_BASETYPE (type);
11289             }
11290           if (ctype)
11291             {
11292               tree dummy = build_decl (TYPE_DECL, declarator, type);
11293               grok_method_quals (ctype, dummy, quals);
11294               type = TREE_TYPE (dummy);
11295             }
11296         }
11297
11298       return type;
11299     }
11300   else if (declarator == NULL_TREE && decl_context != PARM
11301            && decl_context != CATCHPARM
11302            && TREE_CODE (type) != UNION_TYPE
11303            && ! bitfield)
11304     {
11305       cp_error ("abstract declarator `%T' used as declaration", type);
11306       declarator = make_anon_name ();
11307     }
11308
11309   /* `void' at top level (not within pointer)
11310      is allowed only in typedefs or type names.
11311      We don't complain about parms either, but that is because
11312      a better error message can be made later.  */
11313
11314   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11315     {
11316       if (! declarator)
11317         error ("unnamed variable or field declared void");
11318       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11319         {
11320           if (IDENTIFIER_OPNAME_P (declarator))
11321             my_friendly_abort (356);
11322           else
11323             error ("variable or field `%s' declared void", name);
11324         }
11325       else
11326         error ("variable or field declared void");
11327       type = integer_type_node;
11328     }
11329
11330   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11331      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11332
11333   if (decl_context == PARM || decl_context == CATCHPARM)
11334     {
11335       if (ctype || in_namespace)
11336         error ("cannot use `::' in parameter declaration");
11337
11338       /* A parameter declared as an array of T is really a pointer to T.
11339          One declared as a function is really a pointer to a function.
11340          One declared as a member is really a pointer to member.  */
11341
11342       if (TREE_CODE (type) == ARRAY_TYPE)
11343         {
11344           /* Transfer const-ness of array into that of type pointed to.  */
11345           type = build_pointer_type (TREE_TYPE (type));
11346           type_quals = TYPE_UNQUALIFIED;
11347         }
11348       else if (TREE_CODE (type) == FUNCTION_TYPE)
11349         type = build_pointer_type (type);
11350       else if (TREE_CODE (type) == OFFSET_TYPE)
11351         type = build_pointer_type (type);
11352       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11353         {
11354           error ("declaration of `%s' as void", name);
11355           return NULL_TREE;
11356         }
11357     }
11358
11359   {
11360     register tree decl;
11361
11362     if (decl_context == PARM)
11363       {
11364         decl = build_decl (PARM_DECL, declarator, type);
11365
11366         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11367                         inlinep, friendp, raises != NULL_TREE);
11368
11369         /* Compute the type actually passed in the parmlist,
11370            for the case where there is no prototype.
11371            (For example, shorts and chars are passed as ints.)
11372            When there is a prototype, this is overridden later.  */
11373
11374         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11375       }
11376     else if (decl_context == FIELD)
11377       {
11378         if (type == error_mark_node)
11379           {
11380             /* Happens when declaring arrays of sizes which
11381                are error_mark_node, for example.  */
11382             decl = NULL_TREE;
11383           }
11384         else if (in_namespace && !friendp)
11385           {
11386             /* Something like struct S { int N::j; };  */
11387             cp_error ("invalid use of `::'");
11388             decl = NULL_TREE;
11389           }
11390         else if (TREE_CODE (type) == FUNCTION_TYPE)
11391           {
11392             int publicp = 0;
11393             tree function_context;
11394
11395             /* We catch the others as conflicts with the builtin
11396                typedefs.  */
11397             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11398               {
11399                 cp_error ("function `%D' cannot be declared friend",
11400                           declarator);
11401                 friendp = 0;
11402               }
11403
11404             if (friendp == 0)
11405               {
11406                 if (ctype == NULL_TREE)
11407                   ctype = current_class_type;
11408
11409                 if (ctype == NULL_TREE)
11410                   {
11411                     cp_error ("can't make `%D' into a method -- not in a class",
11412                               declarator);
11413                     return void_type_node;
11414                   }
11415
11416                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11417                    ARM 9.5 */
11418                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11419                   {
11420                     cp_error ("function `%D' declared virtual inside a union",
11421                               declarator);
11422                     return void_type_node;
11423                   }
11424
11425                 if (declarator == ansi_opname (NEW_EXPR)
11426                     || declarator == ansi_opname (VEC_NEW_EXPR)
11427                     || declarator == ansi_opname (DELETE_EXPR)
11428                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11429                   {
11430                     if (virtualp)
11431                       {
11432                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11433                                   declarator);
11434                         virtualp = 0;
11435                       }
11436                   }
11437                 else if (staticp < 2)
11438                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11439                                                   TYPE_ARG_TYPES (type));
11440               }
11441
11442             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11443             function_context = (ctype != NULL_TREE) ?
11444               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11445             publicp = (! friendp || ! staticp)
11446               && function_context == NULL_TREE;
11447             decl = grokfndecl (ctype, type,
11448                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11449                                ? declarator : dname,
11450                                declarator,
11451                                virtualp, flags, quals, raises,
11452                                friendp ? -1 : 0, friendp, publicp, inlinep,
11453                                funcdef_flag, template_count, in_namespace);
11454             if (decl == NULL_TREE)
11455               return decl;
11456 #if 0
11457             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11458             /* The decl and setting of decl_machine_attr is also turned off.  */
11459             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11460 #endif
11461
11462             /* [class.conv.ctor]
11463
11464                A constructor declared without the function-specifier
11465                explicit that can be called with a single parameter
11466                specifies a conversion from the type of its first
11467                parameter to the type of its class.  Such a constructor
11468                is called a converting constructor.  */
11469             if (explicitp == 2)
11470               DECL_NONCONVERTING_P (decl) = 1;
11471             else if (DECL_CONSTRUCTOR_P (decl))
11472               {
11473                 /* The constructor can be called with exactly one
11474                    parameter if there is at least one parameter, and
11475                    any subsequent parameters have default arguments.
11476                    We don't look at the first parameter, which is
11477                    really just the `this' parameter for the new
11478                    object.  */
11479                 tree arg_types =
11480                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11481
11482                 /* Skip the `in_chrg' argument too, if present.  */
11483                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11484                   arg_types = TREE_CHAIN (arg_types);
11485
11486                 if (arg_types == void_list_node
11487                     || (arg_types
11488                         && TREE_CHAIN (arg_types)
11489                         && TREE_CHAIN (arg_types) != void_list_node
11490                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11491                   DECL_NONCONVERTING_P (decl) = 1;
11492               }
11493           }
11494         else if (TREE_CODE (type) == METHOD_TYPE)
11495           {
11496             /* We only get here for friend declarations of
11497                members of other classes.  */
11498             /* All method decls are public, so tell grokfndecl to set
11499                TREE_PUBLIC, also.  */
11500             decl = grokfndecl (ctype, type, declarator, declarator,
11501                                virtualp, flags, quals, raises,
11502                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11503                                template_count, in_namespace);
11504             if (decl == NULL_TREE)
11505               return NULL_TREE;
11506           }
11507         else if (!staticp && ! processing_template_decl
11508                  && !COMPLETE_TYPE_P (complete_type (type))
11509                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11510           {
11511             if (declarator)
11512               cp_error ("field `%D' has incomplete type", declarator);
11513             else
11514               cp_error ("name `%T' has incomplete type", type);
11515
11516             /* If we're instantiating a template, tell them which
11517                instantiation made the field's type be incomplete.  */
11518             if (current_class_type
11519                 && TYPE_NAME (current_class_type)
11520                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11521                 && declspecs && TREE_VALUE (declspecs)
11522                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11523               cp_error ("  in instantiation of template `%T'",
11524                         current_class_type);
11525
11526             type = error_mark_node;
11527             decl = NULL_TREE;
11528           }
11529         else
11530           {
11531             if (friendp)
11532               {
11533                 error ("`%s' is neither function nor member function; cannot be declared friend",
11534                        IDENTIFIER_POINTER (declarator));
11535                 friendp = 0;
11536               }
11537             decl = NULL_TREE;
11538           }
11539
11540         if (friendp)
11541           {
11542             /* Friends are treated specially.  */
11543             if (ctype == current_class_type)
11544               warning ("member functions are implicitly friends of their class");
11545             else
11546               {
11547                 tree t = NULL_TREE;
11548                 if (decl && DECL_NAME (decl))
11549                   {
11550                     if (template_class_depth (current_class_type) == 0)
11551                       {
11552                         decl
11553                           = check_explicit_specialization
11554                           (declarator, decl,
11555                            template_count, 2 * (funcdef_flag != 0) + 4);
11556                         if (decl == error_mark_node)
11557                           return error_mark_node;
11558                       }
11559
11560                     t = do_friend (ctype, declarator, decl,
11561                                    last_function_parms, attrlist, flags, quals,
11562                                    funcdef_flag);
11563                   }
11564                 if (t && funcdef_flag)
11565                   return t;
11566
11567                 return void_type_node;
11568               }
11569           }
11570
11571         /* Structure field.  It may not be a function, except for C++ */
11572
11573         if (decl == NULL_TREE)
11574           {
11575             if (initialized)
11576               {
11577                 if (!staticp)
11578                   {
11579                     /* An attempt is being made to initialize a non-static
11580                        member.  But, from [class.mem]:
11581
11582                        4 A member-declarator can contain a
11583                        constant-initializer only if it declares a static
11584                        member (_class.static_) of integral or enumeration
11585                        type, see _class.static.data_.
11586
11587                        This used to be relatively common practice, but
11588                        the rest of the compiler does not correctly
11589                        handle the initialization unless the member is
11590                        static so we make it static below.  */
11591                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11592                                 declarator);
11593                     cp_pedwarn ("making `%D' static", declarator);
11594                     staticp = 1;
11595                   }
11596
11597                 if (uses_template_parms (type))
11598                   /* We'll check at instantiation time.  */
11599                   ;
11600                 else if (check_static_variable_definition (declarator,
11601                                                            type))
11602                   /* If we just return the declaration, crashes
11603                      will sometimes occur.  We therefore return
11604                      void_type_node, as if this was a friend
11605                      declaration, to cause callers to completely
11606                      ignore this declaration.  */
11607                   return void_type_node;
11608               }
11609
11610             /* 9.2p13 [class.mem] */
11611             if (declarator == constructor_name (current_class_type)
11612                 /* The standard does not allow non-static data members
11613                    here either, but we agreed at the 10/99 meeting
11614                    to change that in TC 1 so that they are allowed in
11615                    classes with no user-defined constructors.  */
11616                 && staticp)
11617               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11618                           declarator);
11619
11620             if (staticp)
11621               {
11622                 /* C++ allows static class members.  All other work
11623                    for this is done by grokfield.  */
11624                 decl = build_lang_decl (VAR_DECL, declarator, type);
11625                 TREE_STATIC (decl) = 1;
11626                 /* In class context, 'static' means public access.  */
11627                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11628               }
11629             else
11630               {
11631                 decl = build_decl (FIELD_DECL, declarator, type);
11632                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11633                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11634                   {
11635                     DECL_MUTABLE_P (decl) = 1;
11636                     RIDBIT_RESET (RID_MUTABLE, specbits);
11637                   }
11638               }
11639
11640             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11641                             inlinep, friendp, raises != NULL_TREE);
11642           }
11643       }
11644     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11645       {
11646         tree original_name;
11647         int publicp = 0;
11648
11649         if (! declarator)
11650           return NULL_TREE;
11651
11652         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11653           original_name = dname;
11654         else
11655           original_name = declarator;
11656
11657         if (RIDBIT_SETP (RID_AUTO, specbits))
11658           error ("storage class `auto' invalid for function `%s'", name);
11659         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11660           error ("storage class `register' invalid for function `%s'", name);
11661
11662         /* Function declaration not at top level.
11663            Storage classes other than `extern' are not allowed
11664            and `extern' makes no difference.  */
11665         if (! toplevel_bindings_p ()
11666             && (RIDBIT_SETP (RID_STATIC, specbits)
11667                 || RIDBIT_SETP (RID_INLINE, specbits))
11668             && pedantic)
11669           {
11670             if (RIDBIT_SETP (RID_STATIC, specbits))
11671               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11672             else
11673               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11674           }
11675
11676         if (ctype == NULL_TREE)
11677           {
11678             if (virtualp)
11679               {
11680                 error ("virtual non-class function `%s'", name);
11681                 virtualp = 0;
11682               }
11683           }
11684         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11685           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11686                                           TYPE_ARG_TYPES (type));
11687
11688         /* Record presence of `static'.  */
11689         publicp = (ctype != NULL_TREE
11690                    || RIDBIT_SETP (RID_EXTERN, specbits)
11691                    || !RIDBIT_SETP (RID_STATIC, specbits));
11692
11693         decl = grokfndecl (ctype, type, original_name, declarator,
11694                            virtualp, flags, quals, raises,
11695                            1, friendp,
11696                            publicp, inlinep, funcdef_flag,
11697                            template_count, in_namespace);
11698         if (decl == NULL_TREE)
11699           return NULL_TREE;
11700
11701         if (staticp == 1)
11702           {
11703             int illegal_static = 0;
11704
11705             /* Don't allow a static member function in a class, and forbid
11706                declaring main to be static.  */
11707             if (TREE_CODE (type) == METHOD_TYPE)
11708               {
11709                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11710                 illegal_static = 1;
11711               }
11712             else if (current_function_decl)
11713               {
11714                 /* FIXME need arm citation */
11715                 error ("cannot declare static function inside another function");
11716                 illegal_static = 1;
11717               }
11718
11719             if (illegal_static)
11720               {
11721                 staticp = 0;
11722                 RIDBIT_RESET (RID_STATIC, specbits);
11723               }
11724           }
11725       }
11726     else
11727       {
11728         /* It's a variable.  */
11729
11730         /* An uninitialized decl with `extern' is a reference.  */
11731         decl = grokvardecl (type, declarator, &specbits,
11732                             initialized,
11733                             (type_quals & TYPE_QUAL_CONST) != 0,
11734                             in_namespace);
11735         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11736                         inlinep, friendp, raises != NULL_TREE);
11737
11738         if (ctype)
11739           {
11740             DECL_CONTEXT (decl) = ctype;
11741             if (staticp == 1)
11742               {
11743                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11744                 staticp = 0;
11745                 RIDBIT_RESET (RID_STATIC, specbits);
11746               }
11747             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11748               {
11749                 cp_error ("static member `%D' declared `register'", decl);
11750                 RIDBIT_RESET (RID_REGISTER, specbits);
11751               }
11752             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11753               {
11754                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11755                             decl);
11756                 RIDBIT_RESET (RID_EXTERN, specbits);
11757               }
11758           }
11759       }
11760
11761     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11762
11763     /* Record `register' declaration for warnings on &
11764        and in case doing stupid register allocation.  */
11765
11766     if (RIDBIT_SETP (RID_REGISTER, specbits))
11767       DECL_REGISTER (decl) = 1;
11768
11769     if (RIDBIT_SETP (RID_EXTERN, specbits))
11770       DECL_THIS_EXTERN (decl) = 1;
11771
11772     if (RIDBIT_SETP (RID_STATIC, specbits))
11773       DECL_THIS_STATIC (decl) = 1;
11774
11775     /* Record constancy and volatility.  There's no need to do this
11776        when processing a template; we'll do this for the instantiated
11777        declaration based on the type of DECL.  */
11778     if (!processing_template_decl)
11779       c_apply_type_quals_to_decl (type_quals, decl);
11780
11781     return decl;
11782   }
11783 }
11784 \f
11785 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11786    An empty exprlist is a parmlist.  An exprlist which
11787    contains only identifiers at the global level
11788    is a parmlist.  Otherwise, it is an exprlist.  */
11789
11790 int
11791 parmlist_is_exprlist (exprs)
11792      tree exprs;
11793 {
11794   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11795     return 0;
11796
11797   if (toplevel_bindings_p ())
11798     {
11799       /* At the global level, if these are all identifiers,
11800          then it is a parmlist.  */
11801       while (exprs)
11802         {
11803           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11804             return 1;
11805           exprs = TREE_CHAIN (exprs);
11806         }
11807       return 0;
11808     }
11809   return 1;
11810 }
11811
11812 /* Subroutine of start_function.  Ensure that each of the parameter
11813    types (as listed in PARMS) is complete, as is required for a
11814    function definition.  */
11815
11816 static void
11817 require_complete_types_for_parms (parms)
11818      tree parms;
11819 {
11820   for (; parms; parms = TREE_CHAIN (parms))
11821     {
11822       tree type = TREE_TYPE (parms);
11823
11824       /* Try to complete the TYPE.  */
11825       type = complete_type (type);
11826
11827       if (type == error_mark_node)
11828         continue;
11829
11830       if (!COMPLETE_TYPE_P (type))
11831         {
11832           if (DECL_NAME (parms))
11833             error ("parameter `%s' has incomplete type",
11834                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11835           else
11836             error ("parameter has incomplete type");
11837           TREE_TYPE (parms) = error_mark_node;
11838         }
11839       else
11840         layout_decl (parms, 0);
11841     }
11842 }
11843
11844 /* Returns non-zero if T is a local variable.  */
11845
11846 int
11847 local_variable_p (t)
11848      tree t;
11849 {
11850   if ((TREE_CODE (t) == VAR_DECL
11851        /* A VAR_DECL with a context that is a _TYPE is a static data
11852           member.  */
11853        && !TYPE_P (CP_DECL_CONTEXT (t))
11854        /* Any other non-local variable must be at namespace scope.  */
11855        && !DECL_NAMESPACE_SCOPE_P (t))
11856       || (TREE_CODE (t) == PARM_DECL))
11857     return 1;
11858
11859   return 0;
11860 }
11861
11862 /* Returns non-zero if T is an automatic local variable or a label.
11863    (These are the declarations that need to be remapped when the code
11864    containing them is duplicated.)  */
11865
11866 int
11867 nonstatic_local_decl_p (t)
11868      tree t;
11869 {
11870   return ((local_variable_p (t) && !TREE_STATIC (t))
11871           || TREE_CODE (t) == LABEL_DECL
11872           || TREE_CODE (t) == RESULT_DECL);
11873 }
11874
11875 /* Like local_variable_p, but suitable for use as a tree-walking
11876    function.  */
11877
11878 static tree
11879 local_variable_p_walkfn (tp, walk_subtrees, data)
11880      tree *tp;
11881      int *walk_subtrees ATTRIBUTE_UNUSED;
11882      void *data ATTRIBUTE_UNUSED;
11883 {
11884   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11885           ? *tp : NULL_TREE);
11886 }
11887
11888 /* Check that ARG, which is a default-argument expression for a
11889    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11890    something goes wrong.  DECL may also be a _TYPE node, rather than a
11891    DECL, if there is no DECL available.  */
11892
11893 tree
11894 check_default_argument (decl, arg)
11895      tree decl;
11896      tree arg;
11897 {
11898   tree var;
11899   tree decl_type;
11900
11901   if (TREE_CODE (arg) == DEFAULT_ARG)
11902     /* We get a DEFAULT_ARG when looking at an in-class declaration
11903        with a default argument.  Ignore the argument for now; we'll
11904        deal with it after the class is complete.  */
11905     return arg;
11906
11907   if (processing_template_decl || uses_template_parms (arg))
11908     /* We don't do anything checking until instantiation-time.  Note
11909        that there may be uninstantiated arguments even for an
11910        instantiated function, since default arguments are not
11911        instantiated until they are needed.  */
11912     return arg;
11913
11914   if (TYPE_P (decl))
11915     {
11916       decl_type = decl;
11917       decl = NULL_TREE;
11918     }
11919   else
11920     decl_type = TREE_TYPE (decl);
11921
11922   if (arg == error_mark_node
11923       || decl == error_mark_node
11924       || TREE_TYPE (arg) == error_mark_node
11925       || decl_type == error_mark_node)
11926     /* Something already went wrong.  There's no need to check
11927        further.  */
11928     return error_mark_node;
11929
11930   /* [dcl.fct.default]
11931
11932      A default argument expression is implicitly converted to the
11933      parameter type.  */
11934   if (!TREE_TYPE (arg)
11935       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11936     {
11937       if (decl)
11938         cp_error ("default argument for `%#D' has type `%T'",
11939                   decl, TREE_TYPE (arg));
11940       else
11941         cp_error ("default argument for parameter of type `%T' has type `%T'",
11942                   decl_type, TREE_TYPE (arg));
11943
11944       return error_mark_node;
11945     }
11946
11947   /* [dcl.fct.default]
11948
11949      Local variables shall not be used in default argument
11950      expressions.
11951
11952      The keyword `this' shall not be used in a default argument of a
11953      member function.  */
11954   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11955   if (var)
11956     {
11957       cp_error ("default argument `%E' uses local variable `%D'",
11958                 arg, var);
11959       return error_mark_node;
11960     }
11961
11962   /* All is well.  */
11963   return arg;
11964 }
11965
11966 /* Decode the list of parameter types for a function type.
11967    Given the list of things declared inside the parens,
11968    return a list of types.
11969
11970    The list we receive can have three kinds of elements:
11971    an IDENTIFIER_NODE for names given without types,
11972    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11973    or void_type_node, to mark the end of an argument list
11974    when additional arguments are not permitted (... was not used).
11975
11976    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11977    a mere declaration.  A nonempty identifier-list gets an error message
11978    when FUNCDEF_FLAG is zero.
11979    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11980    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11981
11982    If all elements of the input list contain types,
11983    we return a list of the types.
11984    If all elements contain no type (except perhaps a void_type_node
11985    at the end), we return a null list.
11986    If some have types and some do not, it is an error, and we
11987    return a null list.
11988
11989    Also set last_function_parms to either
11990    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11991    A list of names is converted to a chain of PARM_DECLs
11992    by store_parm_decls so that ultimately it is always a chain of decls.
11993
11994    Note that in C++, parameters can take default values.  These default
11995    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11996    an error to specify default values which are followed by parameters
11997    that have no default values, or an ELLIPSES.  For simplicities sake,
11998    only parameters which are specified with their types can take on
11999    default values.  */
12000
12001 static tree
12002 grokparms (first_parm, funcdef_flag)
12003      tree first_parm;
12004      int funcdef_flag;
12005 {
12006   tree result = NULL_TREE;
12007   tree decls = NULL_TREE;
12008
12009   if (first_parm != NULL_TREE
12010       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
12011     {
12012       if (! funcdef_flag)
12013         pedwarn ("parameter names (without types) in function declaration");
12014       last_function_parms = first_parm;
12015       return NULL_TREE;
12016     }
12017   else if (first_parm != NULL_TREE
12018            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
12019            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
12020     my_friendly_abort (145);
12021   else
12022     {
12023       /* Types were specified.  This is a list of declarators
12024          each represented as a TREE_LIST node.  */
12025       register tree parm, chain;
12026       int any_init = 0, any_error = 0;
12027
12028       if (first_parm != NULL_TREE)
12029         {
12030           tree last_result = NULL_TREE;
12031           tree last_decl = NULL_TREE;
12032
12033           for (parm = first_parm; parm != NULL_TREE; parm = chain)
12034             {
12035               tree type = NULL_TREE, list_node = parm;
12036               register tree decl = TREE_VALUE (parm);
12037               tree init = TREE_PURPOSE (parm);
12038
12039               chain = TREE_CHAIN (parm);
12040               /* @@ weak defense against parse errors.  */
12041               if (TREE_CODE (decl) != VOID_TYPE
12042                   && TREE_CODE (decl) != TREE_LIST)
12043                 {
12044                   /* Give various messages as the need arises.  */
12045                   if (TREE_CODE (decl) == STRING_CST)
12046                     cp_error ("invalid string constant `%E'", decl);
12047                   else if (TREE_CODE (decl) == INTEGER_CST)
12048                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12049                   continue;
12050                 }
12051
12052               if (TREE_CODE (decl) != VOID_TYPE)
12053                 {
12054                   decl = grokdeclarator (TREE_VALUE (decl),
12055                                          TREE_PURPOSE (decl),
12056                                          PARM, init != NULL_TREE,
12057                                          NULL_TREE);
12058                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12059                     continue;
12060
12061                   /* Top-level qualifiers on the parameters are
12062                      ignored for function types.  */
12063                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12064
12065                   if (TREE_CODE (type) == VOID_TYPE)
12066                     decl = void_type_node;
12067                   else if (TREE_CODE (type) == METHOD_TYPE)
12068                     {
12069                       if (DECL_NAME (decl))
12070                         /* Cannot use the decl here because
12071                            we don't have DECL_CONTEXT set up yet.  */
12072                         cp_error ("parameter `%D' invalidly declared method type",
12073                                   DECL_NAME (decl));
12074                       else
12075                         error ("parameter invalidly declared method type");
12076                       type = build_pointer_type (type);
12077                       TREE_TYPE (decl) = type;
12078                     }
12079                   else if (TREE_CODE (type) == OFFSET_TYPE)
12080                     {
12081                       if (DECL_NAME (decl))
12082                         cp_error ("parameter `%D' invalidly declared offset type",
12083                                   DECL_NAME (decl));
12084                       else
12085                         error ("parameter invalidly declared offset type");
12086                       type = build_pointer_type (type);
12087                       TREE_TYPE (decl) = type;
12088                     }
12089                   else if (abstract_virtuals_error (decl, type))
12090                     any_error = 1;  /* Seems like a good idea. */
12091                   else if (POINTER_TYPE_P (type))
12092                     {
12093                       tree t = type;
12094                       while (POINTER_TYPE_P (t)
12095                              || (TREE_CODE (t) == ARRAY_TYPE
12096                                  && TYPE_DOMAIN (t) != NULL_TREE))
12097                         t = TREE_TYPE (t);
12098                       if (TREE_CODE (t) == ARRAY_TYPE)
12099                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12100                                   type,
12101                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12102                     }
12103                 }
12104
12105               if (TREE_CODE (decl) == VOID_TYPE)
12106                 {
12107                   if (result == NULL_TREE)
12108                     {
12109                       result = void_list_node;
12110                       last_result = result;
12111                     }
12112                   else
12113                     {
12114                       TREE_CHAIN (last_result) = void_list_node;
12115                       last_result = void_list_node;
12116                     }
12117                   if (chain
12118                       && (chain != void_list_node || TREE_CHAIN (chain)))
12119                     error ("`void' in parameter list must be entire list");
12120                   break;
12121                 }
12122
12123               /* Since there is a prototype, args are passed in their own types.  */
12124               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12125               if (PROMOTE_PROTOTYPES
12126                   && (TREE_CODE (type) == INTEGER_TYPE
12127                       || TREE_CODE (type) == ENUMERAL_TYPE)
12128                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12129                 DECL_ARG_TYPE (decl) = integer_type_node;
12130               if (!any_error && init)
12131                 {
12132                   any_init++;
12133                   init = check_default_argument (decl, init);
12134                 }
12135               else
12136                 init = NULL_TREE;
12137
12138               if (decls == NULL_TREE)
12139                 {
12140                   decls = decl;
12141                   last_decl = decls;
12142                 }
12143               else
12144                 {
12145                   TREE_CHAIN (last_decl) = decl;
12146                   last_decl = decl;
12147                 }
12148               list_node = tree_cons (init, type, NULL_TREE);
12149               if (result == NULL_TREE)
12150                 {
12151                   result = list_node;
12152                   last_result = result;
12153                 }
12154               else
12155                 {
12156                   TREE_CHAIN (last_result) = list_node;
12157                   last_result = list_node;
12158                 }
12159             }
12160           if (last_result)
12161             TREE_CHAIN (last_result) = NULL_TREE;
12162           /* If there are no parameters, and the function does not end
12163              with `...', then last_decl will be NULL_TREE.  */
12164           if (last_decl != NULL_TREE)
12165             TREE_CHAIN (last_decl) = NULL_TREE;
12166         }
12167     }
12168
12169   last_function_parms = decls;
12170
12171   return result;
12172 }
12173
12174 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12175    FUNCTION_TYPE with the newly parsed version of its default argument, which
12176    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12177
12178 void
12179 replace_defarg (arg, init)
12180      tree arg, init;
12181 {
12182   if (! processing_template_decl
12183       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12184     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12185                 TREE_TYPE (init), TREE_VALUE (arg));
12186   TREE_PURPOSE (arg) = init;
12187 }
12188 \f
12189 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12190    D's arguments allow it to be a copy constructor, or copy assignment
12191    operator.  */
12192
12193 int
12194 copy_args_p (d)
12195      tree d;
12196 {
12197   tree t;
12198
12199   if (!DECL_FUNCTION_MEMBER_P (d))
12200     return 0;
12201
12202   t = FUNCTION_ARG_CHAIN (d);
12203   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12204     t = TREE_CHAIN (t);
12205   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12206       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12207           == DECL_CONTEXT (d))
12208       && (TREE_CHAIN (t) == NULL_TREE
12209           || TREE_CHAIN (t) == void_list_node
12210           || TREE_PURPOSE (TREE_CHAIN (t))))
12211     return 1;
12212   return 0;
12213 }
12214
12215 /* These memoizing functions keep track of special properties which
12216    a class may have.  `grok_ctor_properties' notices whether a class
12217    has a constructor of the form X(X&), and also complains
12218    if the class has a constructor of the form X(X).
12219    `grok_op_properties' takes notice of the various forms of
12220    operator= which are defined, as well as what sorts of type conversion
12221    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12222
12223 int
12224 grok_ctor_properties (ctype, decl)
12225      tree ctype, decl;
12226 {
12227   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12228   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12229
12230   /* When a type has virtual baseclasses, a magical first int argument is
12231      added to any ctor so we can tell if the class has been initialized
12232      yet.  This could screw things up in this function, so we deliberately
12233      ignore the leading int if we're in that situation.  */
12234   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12235     {
12236       my_friendly_assert (parmtypes
12237                           && TREE_VALUE (parmtypes) == integer_type_node,
12238                           980529);
12239       parmtypes = TREE_CHAIN (parmtypes);
12240       parmtype = TREE_VALUE (parmtypes);
12241     }
12242
12243   /* [class.copy]
12244
12245      A non-template constructor for class X is a copy constructor if
12246      its first parameter is of type X&, const X&, volatile X& or const
12247      volatile X&, and either there are no other parameters or else all
12248      other parameters have default arguments.  */
12249   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12250       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12251       && (TREE_CHAIN (parmtypes) == NULL_TREE
12252           || TREE_CHAIN (parmtypes) == void_list_node
12253           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12254       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12255            && is_member_template (DECL_TI_TEMPLATE (decl))))
12256     {
12257       TYPE_HAS_INIT_REF (ctype) = 1;
12258       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12259         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12260     }
12261   /* [class.copy]
12262
12263      A declaration of a constructor for a class X is ill-formed if its
12264      first parameter is of type (optionally cv-qualified) X and either
12265      there are no other parameters or else all other parameters have
12266      default arguments.
12267
12268      We *don't* complain about member template instantiations that
12269      have this form, though; they can occur as we try to decide what
12270      constructor to use during overload resolution.  Since overload
12271      resolution will never prefer such a constructor to the
12272      non-template copy constructor (which is either explicitly or
12273      implicitly defined), there's no need to worry about their
12274      existence.  Theoretically, they should never even be
12275      instantiated, but that's hard to forestall.  */
12276   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12277            && (TREE_CHAIN (parmtypes) == NULL_TREE
12278                || TREE_CHAIN (parmtypes) == void_list_node
12279                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12280            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12281                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12282     {
12283       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12284                 ctype, ctype);
12285       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12286       return 0;
12287     }
12288   else if (TREE_CODE (parmtype) == VOID_TYPE
12289            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12290     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12291
12292   return 1;
12293 }
12294
12295 /* An operator with this code is unary, but can also be binary.  */
12296
12297 static int
12298 ambi_op_p (code)
12299      enum tree_code code;
12300 {
12301   return (code == INDIRECT_REF
12302           || code == ADDR_EXPR
12303           || code == CONVERT_EXPR
12304           || code == NEGATE_EXPR
12305           || code == PREINCREMENT_EXPR
12306           || code == PREDECREMENT_EXPR);
12307 }
12308
12309 /* An operator with this name can only be unary.  */
12310
12311 static int
12312 unary_op_p (code)
12313      enum tree_code code;
12314 {
12315   return (code == TRUTH_NOT_EXPR
12316           || code == BIT_NOT_EXPR
12317           || code == COMPONENT_REF
12318           || code == TYPE_EXPR);
12319 }
12320
12321 /* Do a little sanity-checking on how they declared their operator.  */
12322
12323 void
12324 grok_op_properties (decl, virtualp, friendp)
12325      tree decl;
12326      int virtualp, friendp;
12327 {
12328   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12329   tree argtype;
12330   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12331   tree name = DECL_NAME (decl);
12332   enum tree_code operator_code;
12333   int arity;
12334
12335   /* Count the number of arguments.  */
12336   for (argtype = argtypes, arity = 0;
12337        argtype && argtype != void_list_node;
12338        argtype = TREE_CHAIN (argtype))
12339     ++arity;
12340
12341   if (current_class_type == NULL_TREE)
12342     friendp = 1;
12343
12344   if (DECL_CONV_FN_P (decl))
12345     operator_code = TYPE_EXPR;
12346   else
12347     do
12348       {
12349 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12350         if (ansi_opname (CODE) == name)                                     \
12351           {                                                                 \
12352             operator_code = CODE;                                           \
12353             break;                                                          \
12354           }                                                                 \
12355         else if (ansi_assopname (CODE) == name)                             \
12356           {                                                                 \
12357             operator_code = CODE;                                           \
12358             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12359             break;                                                          \
12360           }
12361
12362 #include "operators.def"
12363 #undef DEF_OPERATOR
12364
12365         my_friendly_abort (20000527);
12366       }
12367     while (0);
12368   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12369   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12370
12371   if (! friendp)
12372     {
12373       switch (operator_code)
12374         {
12375         case CALL_EXPR:
12376           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12377           break;
12378
12379         case ARRAY_REF:
12380           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12381           break;
12382
12383         case COMPONENT_REF:
12384         case MEMBER_REF:
12385           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12386           break;
12387
12388         case NEW_EXPR:
12389           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12390           break;
12391
12392         case DELETE_EXPR:
12393           TYPE_GETS_DELETE (current_class_type) |= 1;
12394           break;
12395
12396         case VEC_NEW_EXPR:
12397           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12398           break;
12399
12400         case VEC_DELETE_EXPR:
12401           TYPE_GETS_DELETE (current_class_type) |= 2;
12402           break;
12403
12404         default:
12405           break;
12406         }
12407     }
12408
12409   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12410     {
12411       /* When the compiler encounters the definition of A::operator new, it
12412          doesn't look at the class declaration to find out if it's static.  */
12413       if (methodp)
12414         revert_static_member_fn (decl);
12415
12416       /* Take care of function decl if we had syntax errors.  */
12417       if (argtypes == NULL_TREE)
12418         TREE_TYPE (decl)
12419           = build_function_type (ptr_type_node,
12420                                  hash_tree_chain (integer_type_node,
12421                                                   void_list_node));
12422       else
12423         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12424     }
12425   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12426     {
12427       if (methodp)
12428         revert_static_member_fn (decl);
12429
12430       if (argtypes == NULL_TREE)
12431         TREE_TYPE (decl)
12432           = build_function_type (void_type_node,
12433                                  hash_tree_chain (ptr_type_node,
12434                                                   void_list_node));
12435       else
12436         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12437     }
12438   else
12439     {
12440       /* An operator function must either be a non-static member function
12441          or have at least one parameter of a class, a reference to a class,
12442          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12443       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12444         {
12445           if (operator_code == TYPE_EXPR
12446               || operator_code == CALL_EXPR
12447               || operator_code == COMPONENT_REF
12448               || operator_code == ARRAY_REF
12449               || operator_code == NOP_EXPR)
12450             cp_error ("`%D' must be a nonstatic member function", decl);
12451           else
12452             {
12453               tree p = argtypes;
12454
12455               if (DECL_STATIC_FUNCTION_P (decl))
12456                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12457
12458               if (p)
12459                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12460                   {
12461                     tree arg = TREE_VALUE (p);
12462                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12463                       arg = TREE_TYPE (arg);
12464
12465                     /* This lets bad template code slip through.  */
12466                     if (IS_AGGR_TYPE (arg)
12467                         || TREE_CODE (arg) == ENUMERAL_TYPE
12468                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12469                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12470                       goto foundaggr;
12471                   }
12472               cp_error
12473                 ("`%D' must have an argument of class or enumerated type",
12474                  decl);
12475             foundaggr:
12476               ;
12477             }
12478         }
12479
12480       if (operator_code == CALL_EXPR)
12481         return;                 /* No restrictions on args. */
12482
12483       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12484         {
12485           tree t = TREE_TYPE (name);
12486           if (! friendp)
12487             {
12488               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12489               const char *what = 0;
12490
12491               if (ref)
12492                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12493
12494               if (TREE_CODE (t) == VOID_TYPE)
12495                 what = "void";
12496               else if (t == current_class_type)
12497                 what = "the same type";
12498               /* Don't force t to be complete here.  */
12499               else if (IS_AGGR_TYPE (t)
12500                        && COMPLETE_TYPE_P (t)
12501                        && DERIVED_FROM_P (t, current_class_type))
12502                 what = "a base class";
12503
12504               if (what)
12505                 warning ("conversion to %s%s will never use a type conversion operator",
12506                          ref ? "a reference to " : "", what);
12507             }
12508         }
12509
12510       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12511           && operator_code == NOP_EXPR)
12512         {
12513           tree parmtype;
12514
12515           if (arity != 2 && methodp)
12516             {
12517               cp_error ("`%D' must take exactly one argument", decl);
12518               return;
12519             }
12520           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12521
12522           /* [class.copy]
12523
12524              A user-declared copy assignment operator X::operator= is
12525              a non-static non-template member function of class X with
12526              exactly one parameter of type X, X&, const X&, volatile
12527              X& or const volatile X&.  */
12528           if (copy_assignment_arg_p (parmtype, virtualp)
12529               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12530                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12531               && ! friendp)
12532             {
12533               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12534               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12535                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12536                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12537             }
12538         }
12539       else if (operator_code == COND_EXPR)
12540         {
12541           /* 13.4.0.3 */
12542           cp_error ("ISO C++ prohibits overloading operator ?:");
12543         }
12544       else if (ambi_op_p (operator_code))
12545         {
12546           if (arity == 1)
12547             /* We pick the one-argument operator codes by default, so
12548                we don't have to change anything.  */
12549             ;
12550           else if (arity == 2)
12551             {
12552               /* If we thought this was a unary operator, we now know
12553                  it to be a binary operator.  */
12554               switch (operator_code)
12555                 {
12556                 case INDIRECT_REF:
12557                   operator_code = MULT_EXPR;
12558                   break;
12559
12560                 case ADDR_EXPR:
12561                   operator_code = BIT_AND_EXPR;
12562                   break;
12563
12564                 case CONVERT_EXPR:
12565                   operator_code = PLUS_EXPR;
12566                   break;
12567
12568                 case NEGATE_EXPR:
12569                   operator_code = MINUS_EXPR;
12570                   break;
12571
12572                 case PREINCREMENT_EXPR:
12573                   operator_code = POSTINCREMENT_EXPR;
12574                   break;
12575
12576                 case PREDECREMENT_EXPR:
12577                   operator_code = PREDECREMENT_EXPR;
12578                   break;
12579
12580                 default:
12581                   my_friendly_abort (20000527);
12582                 }
12583
12584               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12585
12586               if ((operator_code == POSTINCREMENT_EXPR
12587                    || operator_code == POSTDECREMENT_EXPR)
12588                   && ! processing_template_decl
12589                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12590                 {
12591                   if (methodp)
12592                     cp_error ("postfix `%D' must take `int' as its argument",
12593                               decl);
12594                   else
12595                     cp_error
12596                       ("postfix `%D' must take `int' as its second argument",
12597                        decl);
12598                 }
12599             }
12600           else
12601             {
12602               if (methodp)
12603                 cp_error ("`%D' must take either zero or one argument", decl);
12604               else
12605                 cp_error ("`%D' must take either one or two arguments", decl);
12606             }
12607
12608           /* More Effective C++ rule 6.  */
12609           if (warn_ecpp
12610               && (operator_code == POSTINCREMENT_EXPR
12611                   || operator_code == POSTDECREMENT_EXPR
12612                   || operator_code == PREINCREMENT_EXPR
12613                   || operator_code == PREDECREMENT_EXPR))
12614             {
12615               tree arg = TREE_VALUE (argtypes);
12616               tree ret = TREE_TYPE (TREE_TYPE (decl));
12617               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12618                 arg = TREE_TYPE (arg);
12619               arg = TYPE_MAIN_VARIANT (arg);
12620               if (operator_code == PREINCREMENT_EXPR
12621                   || operator_code == PREDECREMENT_EXPR)
12622                 {
12623                   if (TREE_CODE (ret) != REFERENCE_TYPE
12624                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12625                                        arg))
12626                     cp_warning ("prefix `%D' should return `%T'", decl,
12627                                 build_reference_type (arg));
12628                 }
12629               else
12630                 {
12631                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12632                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12633                 }
12634             }
12635         }
12636       else if (unary_op_p (operator_code))
12637         {
12638           if (arity != 1)
12639             {
12640               if (methodp)
12641                 cp_error ("`%D' must take `void'", decl);
12642               else
12643                 cp_error ("`%D' must take exactly one argument", decl);
12644             }
12645         }
12646       else /* if (binary_op_p (operator_code)) */
12647         {
12648           if (arity != 2)
12649             {
12650               if (methodp)
12651                 cp_error ("`%D' must take exactly one argument", decl);
12652               else
12653                 cp_error ("`%D' must take exactly two arguments", decl);
12654             }
12655
12656           /* More Effective C++ rule 7.  */
12657           if (warn_ecpp
12658               && (operator_code == TRUTH_ANDIF_EXPR
12659                   || operator_code == TRUTH_ORIF_EXPR
12660                   || operator_code == COMPOUND_EXPR))
12661             cp_warning ("user-defined `%D' always evaluates both arguments",
12662                         decl);
12663         }
12664
12665       /* Effective C++ rule 23.  */
12666       if (warn_ecpp
12667           && arity == 2
12668           && (operator_code == PLUS_EXPR
12669               || operator_code == MINUS_EXPR
12670               || operator_code == TRUNC_DIV_EXPR
12671               || operator_code == MULT_EXPR)
12672           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12673         cp_warning ("`%D' should return by value", decl);
12674
12675       /* 13.4.0.8 */
12676       for (; argtypes && argtypes != void_list_node;
12677           argtypes = TREE_CHAIN (argtypes))
12678         if (TREE_PURPOSE (argtypes))
12679           {
12680             TREE_PURPOSE (argtypes) = NULL_TREE;
12681             if (operator_code == POSTINCREMENT_EXPR
12682                 || operator_code == POSTDECREMENT_EXPR)
12683               {
12684                 if (pedantic)
12685                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12686               }
12687             else
12688               cp_error ("`%D' cannot have default arguments", decl);
12689           }
12690
12691     }
12692 }
12693 \f
12694 static const char *
12695 tag_name (code)
12696      enum tag_types code;
12697 {
12698   switch (code)
12699     {
12700     case record_type:
12701       return "struct";
12702     case class_type:
12703       return "class";
12704     case union_type:
12705       return "union ";
12706     case enum_type:
12707       return "enum";
12708     default:
12709       my_friendly_abort (981122);
12710     }
12711 }
12712
12713 /* Get the struct, enum or union (CODE says which) with tag NAME.
12714    Define the tag as a forward-reference if it is not defined.
12715
12716    C++: If a class derivation is given, process it here, and report
12717    an error if multiple derivation declarations are not identical.
12718
12719    If this is a definition, come in through xref_tag and only look in
12720    the current frame for the name (since C++ allows new names in any
12721    scope.)  */
12722
12723 tree
12724 xref_tag (code_type_node, name, globalize)
12725      tree code_type_node;
12726      tree name;
12727      int globalize;
12728 {
12729   enum tag_types tag_code;
12730   enum tree_code code;
12731   register tree ref, t;
12732   struct binding_level *b = current_binding_level;
12733   int got_type = 0;
12734   tree attributes = NULL_TREE;
12735   tree context = NULL_TREE;
12736
12737   /* If we are called from the parser, code_type_node will sometimes be a
12738      TREE_LIST.  This indicates that the user wrote
12739      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12740      use them later.  */
12741   if (TREE_CODE (code_type_node) == TREE_LIST)
12742     {
12743       attributes = TREE_PURPOSE (code_type_node);
12744       code_type_node = TREE_VALUE (code_type_node);
12745     }
12746
12747   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12748   switch (tag_code)
12749     {
12750     case record_type:
12751     case class_type:
12752       code = RECORD_TYPE;
12753       break;
12754     case union_type:
12755       code = UNION_TYPE;
12756       break;
12757     case enum_type:
12758       code = ENUMERAL_TYPE;
12759       break;
12760     default:
12761       my_friendly_abort (18);
12762     }
12763
12764   /* If a cross reference is requested, look up the type
12765      already defined for this tag and return it.  */
12766   if (TYPE_P (name))
12767     {
12768       t = name;
12769       name = TYPE_IDENTIFIER (t);
12770       got_type = 1;
12771     }
12772   else
12773     t = IDENTIFIER_TYPE_VALUE (name);
12774
12775   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12776       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12777     t = NULL_TREE;
12778
12779   if (! globalize)
12780     {
12781       /* If we know we are defining this tag, only look it up in
12782          this scope and don't try to find it as a type.  */
12783       ref = lookup_tag (code, name, b, 1);
12784     }
12785   else
12786     {
12787       if (t)
12788         {
12789           /* [dcl.type.elab] If the identifier resolves to a
12790              typedef-name or a template type-parameter, the
12791              elaborated-type-specifier is ill-formed.  */
12792           if (t != TYPE_MAIN_VARIANT (t)
12793               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12794             cp_pedwarn ("using typedef-name `%D' after `%s'",
12795                         TYPE_NAME (t), tag_name (tag_code));
12796           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12797             cp_error ("using template type parameter `%T' after `%s'",
12798                       t, tag_name (tag_code));
12799
12800           ref = t;
12801         }
12802       else
12803         ref = lookup_tag (code, name, b, 0);
12804
12805       if (! ref)
12806         {
12807           /* Try finding it as a type declaration.  If that wins,
12808              use it.  */
12809           ref = lookup_name (name, 1);
12810
12811           if (ref != NULL_TREE
12812               && processing_template_decl
12813               && DECL_CLASS_TEMPLATE_P (ref)
12814               && template_class_depth (current_class_type) == 0)
12815             /* Since GLOBALIZE is true, we're declaring a global
12816                template, so we want this type.  */
12817             ref = DECL_TEMPLATE_RESULT (ref);
12818
12819           if (ref && TREE_CODE (ref) == TYPE_DECL
12820               && TREE_CODE (TREE_TYPE (ref)) == code)
12821             ref = TREE_TYPE (ref);
12822           else
12823             ref = NULL_TREE;
12824         }
12825
12826       if (ref && current_class_type
12827           && template_class_depth (current_class_type)
12828           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12829         {
12830           /* Since GLOBALIZE is non-zero, we are not looking at a
12831              definition of this tag.  Since, in addition, we are currently
12832              processing a (member) template declaration of a template
12833              class, we must be very careful; consider:
12834
12835                template <class X>
12836                struct S1
12837
12838                template <class U>
12839                struct S2
12840                { template <class V>
12841                friend struct S1; };
12842
12843              Here, the S2::S1 declaration should not be confused with the
12844              outer declaration.  In particular, the inner version should
12845              have a template parameter of level 2, not level 1.  This
12846              would be particularly important if the member declaration
12847              were instead:
12848
12849                template <class V = U> friend struct S1;
12850
12851              say, when we should tsubst into `U' when instantiating
12852              S2.  On the other hand, when presented with:
12853
12854                  template <class T>
12855                  struct S1 {
12856                    template <class U>
12857                    struct S2 {};
12858                    template <class U>
12859                    friend struct S2;
12860                  };
12861
12862               we must find the inner binding eventually.  We
12863               accomplish this by making sure that the new type we
12864               create to represent this declaration has the right
12865               TYPE_CONTEXT.  */
12866           context = TYPE_CONTEXT (ref);
12867           ref = NULL_TREE;
12868         }
12869     }
12870
12871   if (! ref)
12872     {
12873       /* If no such tag is yet defined, create a forward-reference node
12874          and record it as the "definition".
12875          When a real declaration of this type is found,
12876          the forward-reference will be altered into a real type.  */
12877       if (code == ENUMERAL_TYPE)
12878         {
12879           cp_error ("use of enum `%#D' without previous declaration", name);
12880
12881           ref = make_node (ENUMERAL_TYPE);
12882
12883           /* Give the type a default layout like unsigned int
12884              to avoid crashing if it does not get defined.  */
12885           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12886           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12887           TREE_UNSIGNED (ref) = 1;
12888           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12889           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12890           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12891
12892           /* Enable us to recognize when a type is created in class context.
12893              To do nested classes correctly, this should probably be cleared
12894              out when we leave this classes scope.  Currently this in only
12895              done in `start_enum'.  */
12896
12897           pushtag (name, ref, globalize);
12898         }
12899       else
12900         {
12901           struct binding_level *old_b = class_binding_level;
12902
12903           ref = make_aggr_type (code);
12904           TYPE_CONTEXT (ref) = context;
12905
12906 #ifdef NONNESTED_CLASSES
12907           /* Class types don't nest the way enums do.  */
12908           class_binding_level = (struct binding_level *)0;
12909 #endif
12910           pushtag (name, ref, globalize);
12911           class_binding_level = old_b;
12912         }
12913     }
12914   else
12915     {
12916       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12917         redeclare_class_template (ref, current_template_parms);
12918     }
12919
12920   /* Until the type is defined, tentatively accept whatever
12921      structure tag the user hands us.  */
12922   if (!COMPLETE_TYPE_P (ref)
12923       && ref != current_class_type
12924       /* Have to check this, in case we have contradictory tag info.  */
12925       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12926     {
12927       if (tag_code == class_type)
12928         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12929       else if (tag_code == record_type)
12930         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12931     }
12932
12933   TREE_TYPE (ref) = attributes;
12934
12935   return ref;
12936 }
12937
12938 tree
12939 xref_tag_from_type (old, id, globalize)
12940      tree old, id;
12941      int globalize;
12942 {
12943   tree code_type_node;
12944
12945   if (TREE_CODE (old) == RECORD_TYPE)
12946     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12947                       ? class_type_node : record_type_node);
12948   else
12949     code_type_node = union_type_node;
12950
12951   if (id == NULL_TREE)
12952     id = TYPE_IDENTIFIER (old);
12953
12954   return xref_tag (code_type_node, id, globalize);
12955 }
12956
12957 /* REF is a type (named NAME), for which we have just seen some
12958    baseclasses.  BINFO is a list of those baseclasses; the
12959    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12960    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12961    struct, or union.  */
12962
12963 void
12964 xref_basetypes (code_type_node, name, ref, binfo)
12965      tree code_type_node;
12966      tree name, ref;
12967      tree binfo;
12968 {
12969   /* In the declaration `A : X, Y, ... Z' we mark all the types
12970      (A, X, Y, ..., Z) so we can check for duplicates.  */
12971   tree binfos;
12972   tree base;
12973
12974   int i, len;
12975   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12976
12977   if (tag_code == union_type)
12978     {
12979       cp_error ("derived union `%T' invalid", ref);
12980       return;
12981     }
12982
12983   len = list_length (binfo);
12984
12985   /* First, make sure that any templates in base-classes are
12986      instantiated.  This ensures that if we call ourselves recursively
12987      we do not get confused about which classes are marked and which
12988      are not.  */
12989   for (base = binfo; base; base = TREE_CHAIN (base))
12990     complete_type (TREE_VALUE (base));
12991
12992   SET_CLASSTYPE_MARKED (ref);
12993   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12994
12995   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12996     {
12997       /* The base of a derived struct is public by default.  */
12998       int via_public
12999         = (TREE_PURPOSE (binfo) == access_public_node
13000            || TREE_PURPOSE (binfo) == access_public_virtual_node
13001            || (tag_code != class_type
13002                && (TREE_PURPOSE (binfo) == access_default_node
13003                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13004       int via_protected
13005         = (TREE_PURPOSE (binfo) == access_protected_node
13006            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13007       int via_virtual
13008         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13009            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13010            || TREE_PURPOSE (binfo) == access_public_virtual_node
13011            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13012       tree basetype = TREE_VALUE (binfo);
13013       tree base_binfo;
13014
13015       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13016         basetype = TREE_TYPE (basetype);
13017       if (!basetype
13018           || (TREE_CODE (basetype) != RECORD_TYPE
13019               && TREE_CODE (basetype) != TYPENAME_TYPE
13020               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13021               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
13022         {
13023           cp_error ("base type `%T' fails to be a struct or class type",
13024                     TREE_VALUE (binfo));
13025           continue;
13026         }
13027
13028       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
13029
13030       /* This code replaces similar code in layout_basetypes.
13031          We put the complete_type first for implicit `typename'.  */
13032       if (!COMPLETE_TYPE_P (basetype)
13033           && ! (current_template_parms && uses_template_parms (basetype)))
13034         {
13035           cp_error ("base class `%T' has incomplete type", basetype);
13036           continue;
13037         }
13038       else
13039         {
13040           if (CLASSTYPE_MARKED (basetype))
13041             {
13042               if (basetype == ref)
13043                 cp_error ("recursive type `%T' undefined", basetype);
13044               else
13045                 cp_error ("duplicate base type `%T' invalid", basetype);
13046               continue;
13047             }
13048
13049           if (TYPE_FOR_JAVA (basetype)
13050               && (current_lang_stack
13051                   == &VARRAY_TREE (current_lang_base, 0)))
13052             TYPE_FOR_JAVA (ref) = 1;
13053
13054           /* Note that the BINFO records which describe individual
13055              inheritances are *not* shared in the lattice!  They
13056              cannot be shared because a given baseclass may be
13057              inherited with different `accessibility' by different
13058              derived classes.  (Each BINFO record describing an
13059              individual inheritance contains flags which say what
13060              the `accessibility' of that particular inheritance is.)  */
13061
13062           base_binfo
13063             = make_binfo (size_zero_node, basetype,
13064                           CLASS_TYPE_P (basetype)
13065                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13066                           CLASS_TYPE_P (basetype)
13067                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13068
13069           TREE_VEC_ELT (binfos, i) = base_binfo;
13070           TREE_VIA_PUBLIC (base_binfo) = via_public;
13071           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13072           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13073           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13074
13075           /* We need to unshare the binfos now so that lookups during class
13076              definition work.  */
13077           unshare_base_binfos (base_binfo);
13078
13079           SET_CLASSTYPE_MARKED (basetype);
13080
13081           /* We are free to modify these bits because they are meaningless
13082              at top level, and BASETYPE is a top-level type.  */
13083           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13084             {
13085               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13086               /* Converting to a virtual base class requires looking
13087                  up the offset of the virtual base.  */
13088               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13089             }
13090
13091           if (CLASS_TYPE_P (basetype))
13092             {
13093               TYPE_HAS_NEW_OPERATOR (ref)
13094                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13095               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13096                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13097               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13098               /* If the base-class uses multiple inheritance, so do we.  */
13099               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13100                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13101               /* Likewise, if converting to a base of the base may require
13102                  code, then we may need to generate code to convert to a
13103                  base as well.  */
13104               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13105                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13106             }
13107
13108           i += 1;
13109         }
13110     }
13111   if (i)
13112     TREE_VEC_LENGTH (binfos) = i;
13113   else
13114     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13115
13116   if (i > 1)
13117     {
13118       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13119       /* If there is more than one non-empty they cannot be at the same
13120          address.  */
13121       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13122     }
13123
13124   /* Unmark all the types.  */
13125   while (--i >= 0)
13126     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13127   CLEAR_CLASSTYPE_MARKED (ref);
13128
13129   /* Now that we know all the base-classes, set up the list of virtual
13130      bases.  */
13131   get_vbase_types (ref);
13132 }
13133
13134 \f
13135 /* Begin compiling the definition of an enumeration type.
13136    NAME is its name (or null if anonymous).
13137    Returns the type object, as yet incomplete.
13138    Also records info about it so that build_enumerator
13139    may be used to declare the individual values as they are read.  */
13140
13141 tree
13142 start_enum (name)
13143      tree name;
13144 {
13145   register tree enumtype = NULL_TREE;
13146   struct binding_level *b = current_binding_level;
13147
13148   /* If this is the real definition for a previous forward reference,
13149      fill in the contents in the same object that used to be the
13150      forward reference.  */
13151
13152   if (name != NULL_TREE)
13153     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13154
13155   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13156     {
13157       cp_error ("multiple definition of `%#T'", enumtype);
13158       cp_error_at ("previous definition here", enumtype);
13159       /* Clear out TYPE_VALUES, and start again.  */
13160       TYPE_VALUES (enumtype) = NULL_TREE;
13161     }
13162   else
13163     {
13164       enumtype = make_node (ENUMERAL_TYPE);
13165       pushtag (name, enumtype, 0);
13166     }
13167
13168   if (current_class_type)
13169     TREE_ADDRESSABLE (b->tags) = 1;
13170
13171   GNU_xref_decl (current_function_decl, enumtype);
13172   return enumtype;
13173 }
13174
13175 /* After processing and defining all the values of an enumeration type,
13176    install their decls in the enumeration type and finish it off.
13177    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13178    Returns ENUMTYPE.  */
13179
13180 tree
13181 finish_enum (enumtype)
13182      tree enumtype;
13183 {
13184   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13185   /* Calculate the maximum value of any enumerator in this type.  */
13186
13187   tree values = TYPE_VALUES (enumtype);
13188   if (values)
13189     {
13190       tree pair;
13191
13192       for (pair = values; pair; pair = TREE_CHAIN (pair))
13193         {
13194           tree decl;
13195           tree value;
13196
13197           /* The TREE_VALUE is a CONST_DECL for this enumeration
13198              constant.  */
13199           decl = TREE_VALUE (pair);
13200
13201           /* [dcl.enum]
13202
13203              Following the closing brace of an enum-specifier, each
13204              enumerator has the type of its enumeration.  Prior to the
13205              closing brace, the type of each enumerator is the type of
13206              its initializing value.  */
13207           TREE_TYPE (decl) = enumtype;
13208
13209           /* The DECL_INITIAL will be NULL if we are processing a
13210              template declaration and this enumeration constant had no
13211              explicit initializer.  */
13212           value = DECL_INITIAL (decl);
13213           if (value && !processing_template_decl)
13214             {
13215               /* Set the TREE_TYPE for the VALUE as well.  That's so
13216                  that when we call decl_constant_value we get an
13217                  entity of the right type (but with the constant
13218                  value).  Since we shouldn't ever call
13219                  decl_constant_value on a template type, there's no
13220                  reason to do that when processing_template_decl.
13221                  And, if the expression is something like a
13222                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13223                  wreak havoc on the intended type of the expression.
13224
13225                  Of course, there's also no point in trying to compute
13226                  minimum or maximum values if we're in a template.  */
13227               TREE_TYPE (value) = enumtype;
13228
13229               if (!minnode)
13230                 minnode = maxnode = value;
13231               else if (tree_int_cst_lt (maxnode, value))
13232                 maxnode = value;
13233               else if (tree_int_cst_lt (value, minnode))
13234                 minnode = value;
13235             }
13236
13237           if (processing_template_decl)
13238             /* If this is just a template, leave the CONST_DECL
13239                alone.  That way tsubst_copy will find CONST_DECLs for
13240                CONST_DECLs, and not INTEGER_CSTs.  */
13241             ;
13242           else
13243             /* In the list we're building up, we want the enumeration
13244                values, not the CONST_DECLs.  */
13245             TREE_VALUE (pair) = value;
13246         }
13247     }
13248   else
13249     maxnode = minnode = integer_zero_node;
13250
13251   TYPE_VALUES (enumtype) = nreverse (values);
13252
13253   if (processing_template_decl)
13254     {
13255       tree scope = current_scope ();
13256       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13257         add_tree (build_min (TAG_DEFN, enumtype));
13258     }
13259   else
13260     {
13261       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13262       int lowprec = min_precision (minnode, unsignedp);
13263       int highprec = min_precision (maxnode, unsignedp);
13264       int precision = MAX (lowprec, highprec);
13265       tree tem;
13266
13267       TYPE_SIZE (enumtype) = NULL_TREE;
13268
13269       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13270
13271       TYPE_PRECISION (enumtype) = precision;
13272       if (unsignedp)
13273         fixup_unsigned_type (enumtype);
13274       else
13275         fixup_signed_type (enumtype);
13276
13277       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13278         /* Use the width of the narrowest normal C type which is wide
13279            enough.  */
13280         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13281                                                     (precision, 1));
13282       else
13283         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13284
13285       TYPE_SIZE (enumtype) = 0;
13286       layout_type (enumtype);
13287
13288       /* Fix up all variant types of this enum type.  */
13289       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13290            tem = TYPE_NEXT_VARIANT (tem))
13291         {
13292           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13293           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13294           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13295           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13296           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13297           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13298           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13299           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13300           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13301         }
13302
13303       /* Finish debugging output for this type.  */
13304       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13305     }
13306
13307   return enumtype;
13308 }
13309
13310 /* Build and install a CONST_DECL for an enumeration constant of the
13311    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13312    Assignment of sequential values by default is handled here.  */
13313
13314 void
13315 build_enumerator (name, value, enumtype)
13316      tree name;
13317      tree value;
13318      tree enumtype;
13319 {
13320   tree decl;
13321   tree context;
13322   tree type;
13323   tree values;
13324
13325   /* Remove no-op casts from the value.  */
13326   if (value)
13327     STRIP_TYPE_NOPS (value);
13328
13329   if (! processing_template_decl)
13330     {
13331       /* Validate and default VALUE.  */
13332       if (value != NULL_TREE)
13333         {
13334           value = decl_constant_value (value);
13335
13336           if (TREE_CODE (value) == INTEGER_CST)
13337             {
13338               value = default_conversion (value);
13339               constant_expression_warning (value);
13340             }
13341           else
13342             {
13343               cp_error ("enumerator value for `%D' not integer constant", name);
13344               value = NULL_TREE;
13345             }
13346         }
13347
13348       /* Default based on previous value.  */
13349       if (value == NULL_TREE && ! processing_template_decl)
13350         {
13351           tree prev_value;
13352
13353           if (TYPE_VALUES (enumtype))
13354             {
13355               /* The next value is the previous value ... */
13356               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13357               /* ... plus one.  */
13358               value = build_binary_op (PLUS_EXPR,
13359                                        prev_value,
13360                                        integer_one_node);
13361
13362               if (tree_int_cst_lt (value, prev_value))
13363                 cp_error ("overflow in enumeration values at `%D'", name);
13364             }
13365           else
13366             value = integer_zero_node;
13367         }
13368
13369       /* Remove no-op casts from the value.  */
13370       if (value)
13371         STRIP_TYPE_NOPS (value);
13372 #if 0
13373       /* To fix MAX_VAL enum consts. (bkoz)  */
13374       TREE_TYPE (value) = integer_type_node;
13375 #endif
13376     }
13377
13378   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13379      Even in other cases, we will later (in finish_enum) be setting
13380      the type of VALUE.  But, we don't need to make a copy if this
13381      VALUE is one of the enumeration constants for this same
13382      enumeration type.  */
13383   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13384     if (TREE_VALUE (values) == value)
13385       break;
13386   /* If we didn't break out of the loop, then we do need a copy.  */
13387   if (!values && value)
13388     value = copy_node (value);
13389
13390   /* C++ associates enums with global, function, or class declarations.  */
13391   context = current_scope ();
13392
13393   /* Build the actual enumeration constant.  Note that the enumeration
13394     constants have the type of their initializers until the
13395     enumeration is complete:
13396
13397       [ dcl.enum ]
13398
13399       Following the closing brace of an enum-specifier, each enumer-
13400       ator has the type of its enumeration.  Prior to the closing
13401       brace, the type of each enumerator is the type of its
13402       initializing value.
13403
13404     In finish_enum we will reset the type.  Of course, if we're
13405     processing a template, there may be no value.   */
13406   type = value ? TREE_TYPE (value) : NULL_TREE;
13407
13408   if (context && context == current_class_type)
13409     /* This enum declaration is local to the class.  We need the full
13410       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13411     decl = build_lang_decl (CONST_DECL, name, type);
13412   else
13413     /* It's a global enum, or it's local to a function.  (Note local to
13414       a function could mean local to a class method.  */
13415     decl = build_decl (CONST_DECL, name, type);
13416
13417   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13418   DECL_INITIAL (decl) = value;
13419   TREE_READONLY (decl) = 1;
13420
13421   if (context && context == current_class_type)
13422     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13423       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13424       things like `S::i' later.)  */
13425     finish_member_declaration (decl);
13426   else
13427     {
13428       pushdecl (decl);
13429       GNU_xref_decl (current_function_decl, decl);
13430     }
13431
13432   /* Add this enumeration constant to the list for this type.  */
13433   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13434 }
13435
13436 \f
13437 static int function_depth;
13438
13439 /* We're defining DECL.  Make sure that it's type is OK.  */
13440
13441 static void
13442 check_function_type (decl)
13443      tree decl;
13444 {
13445   tree fntype = TREE_TYPE (decl);
13446   tree return_type = complete_type (TREE_TYPE (fntype));
13447
13448   /* In a function definition, arg types must be complete.  */
13449   require_complete_types_for_parms (current_function_parms);
13450
13451   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13452     {
13453       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13454
13455       /* Make it return void instead, but don't change the
13456          type of the DECL_RESULT, in case we have a named return value.  */
13457       if (TREE_CODE (fntype) == METHOD_TYPE)
13458         {
13459           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13460           TREE_TYPE (decl)
13461             = build_cplus_method_type (ctype,
13462                                        void_type_node,
13463                                        FUNCTION_ARG_CHAIN (decl));
13464         }
13465       else
13466         TREE_TYPE (decl)
13467           = build_function_type (void_type_node,
13468                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13469       TREE_TYPE (decl)
13470         = build_exception_variant (fntype,
13471                                    TYPE_RAISES_EXCEPTIONS (fntype));
13472     }
13473   else
13474     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13475 }
13476
13477 /* Create the FUNCTION_DECL for a function definition.
13478    DECLSPECS and DECLARATOR are the parts of the declaration;
13479    they describe the function's name and the type it returns,
13480    but twisted together in a fashion that parallels the syntax of C.
13481
13482    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13483    DECLARATOR is really the DECL for the function we are about to
13484    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13485    indicating that the function is an inline defined in-class, and
13486    SF_EXPAND indicating that we should generate RTL for this
13487    function.
13488
13489    This function creates a binding context for the function body
13490    as well as setting up the FUNCTION_DECL in current_function_decl.
13491
13492    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13493    (it defines a datum instead), we return 0, which tells
13494    yyparse to report a parse error.
13495
13496    For C++, we must first check whether that datum makes any sense.
13497    For example, "class A local_a(1,2);" means that variable local_a
13498    is an aggregate of type A, which should have a constructor
13499    applied to it with the argument list [1, 2].  */
13500
13501 int
13502 start_function (declspecs, declarator, attrs, flags)
13503      tree declspecs, declarator, attrs;
13504      int flags;
13505 {
13506   tree decl1;
13507   tree ctype = NULL_TREE;
13508   tree fntype;
13509   tree restype;
13510   extern int have_extern_spec;
13511   extern int used_extern_spec;
13512   int doing_friend = 0;
13513   struct binding_level *bl;
13514
13515   /* Sanity check.  */
13516   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13517   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13518
13519   /* This should only be done once on the top most decl.  */
13520   if (have_extern_spec && !used_extern_spec)
13521     {
13522       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13523       used_extern_spec = 1;
13524     }
13525
13526   if (flags & SF_PRE_PARSED)
13527     {
13528       decl1 = declarator;
13529
13530       fntype = TREE_TYPE (decl1);
13531       if (TREE_CODE (fntype) == METHOD_TYPE)
13532         ctype = TYPE_METHOD_BASETYPE (fntype);
13533
13534       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13535          the (lexical) scope of the class in which it is defined.  */
13536       if (!ctype && DECL_FRIEND_P (decl1))
13537         {
13538           ctype = DECL_FRIEND_CONTEXT (decl1);
13539
13540           /* CTYPE could be null here if we're dealing with a template;
13541              for example, `inline friend float foo()' inside a template
13542              will have no CTYPE set.  */
13543           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13544             ctype = NULL_TREE;
13545           else
13546             doing_friend = 1;
13547         }
13548
13549       last_function_parms = DECL_ARGUMENTS (decl1);
13550       last_function_parm_tags = NULL_TREE;
13551     }
13552   else
13553     {
13554       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13555       /* If the declarator is not suitable for a function definition,
13556          cause a syntax error.  */
13557       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13558
13559       fntype = TREE_TYPE (decl1);
13560
13561       restype = TREE_TYPE (fntype);
13562       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13563         {
13564           cp_error ("semicolon missing after declaration of `%#T'", restype);
13565           shadow_tag (build_tree_list (NULL_TREE, restype));
13566           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13567           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13568             fntype = build_function_type (integer_type_node,
13569                                           TYPE_ARG_TYPES (fntype));
13570           else
13571             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13572                                               integer_type_node,
13573                                               TYPE_ARG_TYPES (fntype));
13574           TREE_TYPE (decl1) = fntype;
13575         }
13576
13577       if (TREE_CODE (fntype) == METHOD_TYPE)
13578         ctype = TYPE_METHOD_BASETYPE (fntype);
13579       else if (DECL_MAIN_P (decl1))
13580         {
13581           /* If this doesn't return integer_type, complain.  */
13582           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13583             {
13584               if (pedantic || warn_return_type)
13585                 pedwarn ("return type for `main' changed to `int'");
13586               TREE_TYPE (decl1) = fntype = default_function_type;
13587             }
13588         }
13589     }
13590
13591   /* Sometimes we don't notice that a function is a static member, and
13592      build a METHOD_TYPE for it.  Fix that up now.  */
13593   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13594       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13595     {
13596       revert_static_member_fn (decl1);
13597       last_function_parms = TREE_CHAIN (last_function_parms);
13598       ctype = NULL_TREE;
13599     }
13600
13601   /* Warn if function was previously implicitly declared
13602      (but not if we warned then).  */
13603   if (! warn_implicit
13604       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13605     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13606
13607   /* Set up current_class_type, and enter the scope of the class, if
13608      appropriate.  */
13609   if (ctype)
13610     push_nested_class (ctype, 1);
13611   else if (DECL_STATIC_FUNCTION_P (decl1))
13612     push_nested_class (DECL_CONTEXT (decl1), 2);
13613
13614   /* Now that we have entered the scope of the class, we must restore
13615      the bindings for any template parameters surrounding DECL1, if it
13616      is an inline member template.  (Order is important; consider the
13617      case where a template parameter has the same name as a field of
13618      the class.)  It is not until after this point that
13619      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13620   if (flags & SF_INCLASS_INLINE)
13621     maybe_begin_member_template_processing (decl1);
13622
13623   /* Effective C++ rule 15.  See also c_expand_return.  */
13624   if (warn_ecpp
13625       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13626       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13627     cp_warning ("`operator=' should return a reference to `*this'");
13628
13629   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13630      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13631   if (!DECL_INITIAL (decl1))
13632     DECL_INITIAL (decl1) = error_mark_node;
13633
13634 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13635   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13636 #endif
13637
13638   /* This function exists in static storage.
13639      (This does not mean `static' in the C sense!)  */
13640   TREE_STATIC (decl1) = 1;
13641
13642   /* We must call push_template_decl after current_class_type is set
13643      up.  (If we are processing inline definitions after exiting a
13644      class scope, current_class_type will be NULL_TREE until set above
13645      by push_nested_class.)  */
13646   if (processing_template_decl)
13647     decl1 = push_template_decl (decl1);
13648
13649   /* We are now in the scope of the function being defined.  */
13650   current_function_decl = decl1;
13651
13652   /* Save the parm names or decls from this function's declarator
13653      where store_parm_decls will find them.  */
13654   current_function_parms = last_function_parms;
13655   current_function_parm_tags = last_function_parm_tags;
13656
13657   /* Make sure the parameter and return types are reasonable.  When
13658      you declare a function, these types can be incomplete, but they
13659      must be complete when you define the function.  */
13660   if (! processing_template_decl)
13661     check_function_type (decl1);
13662
13663   /* Build the return declaration for the function.  */
13664   restype = TREE_TYPE (fntype);
13665   if (!processing_template_decl)
13666     {
13667       if (!DECL_RESULT (decl1))
13668         {
13669           DECL_RESULT (decl1)
13670             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13671           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13672                                       DECL_RESULT (decl1));
13673         }
13674     }
13675   else
13676     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13677     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13678
13679   /* Initialize RTL machinery.  We cannot do this until
13680      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13681      even when processing a template; this is how we get
13682      CFUN set up, and our per-function variables initialized.  */
13683   bl = current_binding_level;
13684   init_function_start (decl1, input_filename, lineno);
13685   current_binding_level = bl;
13686   expanding_p = (flags & SF_EXPAND) != 0;
13687
13688   /* Even though we're inside a function body, we still don't want to
13689      call expand_expr to calculate the size of a variable-sized array.
13690      We haven't necessarily assigned RTL to all variables yet, so it's
13691      not safe to try to expand expressions involving them.  */
13692   immediate_size_expand = 0;
13693   cfun->x_dont_save_pending_sizes_p = 1;
13694
13695   /* If we're building a statement-tree, start the tree now.  */
13696   if (processing_template_decl || !expanding_p)
13697     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13698
13699   /* Let the user know we're compiling this function.  */
13700   if (processing_template_decl || !building_stmt_tree ())
13701     announce_function (decl1);
13702
13703   /* Record the decl so that the function name is defined.
13704      If we already have a decl for this name, and it is a FUNCTION_DECL,
13705      use the old decl.  */
13706   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13707     {
13708       /* A specialization is not used to guide overload resolution.  */
13709       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13710           && ! DECL_FUNCTION_MEMBER_P (decl1))
13711         decl1 = pushdecl (decl1);
13712       else
13713         {
13714           /* We need to set the DECL_CONTEXT. */
13715           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13716             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13717           /* And make sure we have enough default args.  */
13718           check_default_args (decl1);
13719         }
13720       fntype = TREE_TYPE (decl1);
13721     }
13722
13723   /* Reset these in case the call to pushdecl changed them.  */
13724   current_function_decl = decl1;
13725   cfun->decl = decl1;
13726
13727   /* Initialize the per-function data.  */
13728   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13729     {
13730       /* If we already parsed this function, and we're just expanding it
13731          now, restore saved state.  */
13732       struct binding_level *bl = current_binding_level;
13733       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13734       current_binding_level = bl;
13735
13736       /* This function is being processed in whole-function mode; we
13737          already did semantic analysis.  */
13738       cfun->x_whole_function_mode_p = 1;
13739
13740       /* If we decided that we didn't want to inline this function,
13741          make sure the back-end knows that.  */
13742       if (!current_function_cannot_inline)
13743         current_function_cannot_inline = cp_function_chain->cannot_inline;
13744
13745       /* We don't need the saved data anymore.  */
13746       free (DECL_SAVED_FUNCTION_DATA (decl1));
13747       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13748     }
13749   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13750     {
13751       /* We know that this was set up by `grokclassfn'.  We do not
13752          wait until `store_parm_decls', since evil parse errors may
13753          never get us to that point.  Here we keep the consistency
13754          between `current_class_type' and `current_class_ptr'.  */
13755       tree t = DECL_ARGUMENTS (decl1);
13756
13757       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13758                           162);
13759       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13760                           19990811);
13761
13762       cp_function_chain->x_current_class_ref
13763         = build_indirect_ref (t, NULL_PTR);
13764       cp_function_chain->x_current_class_ptr = t;
13765
13766       /* Constructors and destructors need to know whether they're "in
13767          charge" of initializing virtual base classes.  */
13768       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13769         current_in_charge_parm = TREE_CHAIN (t);
13770     }
13771
13772   if (DECL_INTERFACE_KNOWN (decl1))
13773     {
13774       tree ctx = decl_function_context (decl1);
13775
13776       if (DECL_NOT_REALLY_EXTERN (decl1))
13777         DECL_EXTERNAL (decl1) = 0;
13778
13779       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13780           && TREE_PUBLIC (ctx))
13781         /* This is a function in a local class in an extern inline
13782            function.  */
13783         comdat_linkage (decl1);
13784     }
13785   /* If this function belongs to an interface, it is public.
13786      If it belongs to someone else's interface, it is also external.
13787      This only affects inlines and template instantiations.  */
13788   else if (interface_unknown == 0
13789            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13790                || flag_alt_external_templates))
13791     {
13792       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13793           || processing_template_decl)
13794         {
13795           DECL_EXTERNAL (decl1)
13796             = (interface_only
13797                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13798                    && !DECL_VINDEX (decl1)));
13799
13800           /* For WIN32 we also want to put these in linkonce sections.  */
13801           maybe_make_one_only (decl1);
13802         }
13803       else
13804         DECL_EXTERNAL (decl1) = 0;
13805       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13806       DECL_INTERFACE_KNOWN (decl1) = 1;
13807     }
13808   else if (interface_unknown && interface_only
13809            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13810                || flag_alt_external_templates))
13811     {
13812       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13813          interface, we will have interface_only set but not
13814          interface_known.  In that case, we don't want to use the normal
13815          heuristics because someone will supply a #pragma implementation
13816          elsewhere, and deducing it here would produce a conflict.  */
13817       comdat_linkage (decl1);
13818       DECL_EXTERNAL (decl1) = 0;
13819       DECL_INTERFACE_KNOWN (decl1) = 1;
13820       DECL_DEFER_OUTPUT (decl1) = 1;
13821     }
13822   else
13823     {
13824       /* This is a definition, not a reference.
13825          So clear DECL_EXTERNAL.  */
13826       DECL_EXTERNAL (decl1) = 0;
13827
13828       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13829           && ! DECL_INTERFACE_KNOWN (decl1)
13830           /* Don't try to defer nested functions for now.  */
13831           && ! decl_function_context (decl1))
13832         DECL_DEFER_OUTPUT (decl1) = 1;
13833       else
13834         DECL_INTERFACE_KNOWN (decl1) = 1;
13835     }
13836
13837   if (doing_semantic_analysis_p ())
13838     {
13839       pushlevel (0);
13840       current_binding_level->parm_flag = 1;
13841     }
13842
13843   if (attrs)
13844     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13845
13846   if (!building_stmt_tree ())
13847     {
13848       GNU_xref_function (decl1, current_function_parms);
13849       make_function_rtl (decl1);
13850     }
13851
13852   /* Promote the value to int before returning it.  */
13853   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13854     restype = type_promotes_to (restype);
13855
13856   /* If this fcn was already referenced via a block-scope `extern' decl
13857      (or an implicit decl), propagate certain information about the usage.  */
13858   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13859     TREE_ADDRESSABLE (decl1) = 1;
13860
13861   if (DECL_RESULT (decl1) == NULL_TREE)
13862     {
13863       DECL_RESULT (decl1)
13864         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13865       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13866       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13867     }
13868
13869   ++function_depth;
13870
13871   if (DECL_DESTRUCTOR_P (decl1))
13872     {
13873       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13874       DECL_CONTEXT (dtor_label) = current_function_decl;
13875     }
13876   /* Under the old ABI we return `this' from constructors, so we make
13877      ordinary `return' statements in constructors jump to CTOR_LABEL;
13878      from there we return `this'.  Under the new ABI, we don't bother
13879      with any of this.  By not setting CTOR_LABEL the remainder of the
13880      machinery is automatically disabled.  */
13881   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13882     {
13883       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13884       DECL_CONTEXT (ctor_label) = current_function_decl;
13885     }
13886
13887   return 1;
13888 }
13889 \f
13890 /* Called after store_parm_decls for a function-try-block.  */
13891
13892 void
13893 expand_start_early_try_stmts ()
13894 {
13895   expand_start_try_stmts ();
13896 }
13897
13898 /* Store the parameter declarations into the current function declaration.
13899    This is called after parsing the parameter declarations, before
13900    digesting the body of the function.
13901
13902    Also install to binding contour return value identifier, if any.  */
13903
13904 void
13905 store_parm_decls ()
13906 {
13907   register tree fndecl = current_function_decl;
13908   register tree parm;
13909   int parms_have_cleanups = 0;
13910   tree cleanups = NULL_TREE;
13911
13912   /* This is a list of types declared among parms in a prototype.  */
13913   tree parmtags = current_function_parm_tags;
13914
13915   /* This is a chain of any other decls that came in among the parm
13916      declarations.  If a parm is declared with  enum {foo, bar} x;
13917      then CONST_DECLs for foo and bar are put here.  */
13918   tree nonparms = NULL_TREE;
13919
13920   /* Create a binding level for the parms.  */
13921   if (!building_stmt_tree ())
13922     expand_start_bindings (2);
13923
13924   if (current_function_parms)
13925     {
13926       /* This case is when the function was defined with an ANSI prototype.
13927          The parms already have decls, so we need not do anything here
13928          except record them as in effect
13929          and complain if any redundant old-style parm decls were written.  */
13930
13931       tree specparms = current_function_parms;
13932       tree next;
13933
13934       if (doing_semantic_analysis_p ())
13935         {
13936           /* Must clear this because it might contain TYPE_DECLs declared
13937              at class level.  */
13938           storedecls (NULL_TREE);
13939
13940           /* If we're doing semantic analysis, then we'll call pushdecl
13941              for each of these.  We must do them in reverse order so that
13942              they end in the correct forward order.  */
13943           specparms = nreverse (specparms);
13944         }
13945
13946       for (parm = specparms; parm; parm = next)
13947         {
13948           next = TREE_CHAIN (parm);
13949           if (TREE_CODE (parm) == PARM_DECL)
13950             {
13951               tree type = TREE_TYPE (parm);
13952
13953               if (doing_semantic_analysis_p ())
13954                 {
13955                   tree cleanup;
13956
13957                   if (DECL_NAME (parm) == NULL_TREE
13958                       || TREE_CODE (parm) != VOID_TYPE)
13959                     pushdecl (parm);
13960                   else
13961                     cp_error ("parameter `%D' declared void", parm);
13962
13963                   cleanup = (processing_template_decl
13964                              ? NULL_TREE
13965                              : maybe_build_cleanup (parm));
13966
13967                   if (cleanup)
13968                     cleanups = tree_cons (parm, cleanup, cleanups);
13969                 }
13970               else if (type != error_mark_node
13971                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13972                 parms_have_cleanups = 1;
13973             }
13974           else
13975             {
13976               /* If we find an enum constant or a type tag,
13977                  put it aside for the moment.  */
13978               TREE_CHAIN (parm) = NULL_TREE;
13979               nonparms = chainon (nonparms, parm);
13980             }
13981         }
13982
13983       if (doing_semantic_analysis_p ())
13984         {
13985           /* Get the decls in their original chain order
13986              and record in the function.  This is all and only the
13987              PARM_DECLs that were pushed into scope by the loop above.  */
13988           DECL_ARGUMENTS (fndecl) = getdecls ();
13989           storetags (chainon (parmtags, gettags ()));
13990         }
13991     }
13992   else
13993     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13994
13995   /* Now store the final chain of decls for the arguments
13996      as the decl-chain of the current lexical scope.
13997      Put the enumerators in as well, at the front so that
13998      DECL_ARGUMENTS is not modified.  */
13999   if (doing_semantic_analysis_p ())
14000     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
14001
14002   /* Initialize the RTL code for the function.  */
14003   DECL_SAVED_INSNS (fndecl) = 0;
14004   if (! building_stmt_tree ())
14005     expand_function_start (fndecl, parms_have_cleanups);
14006
14007   current_function_parms_stored = 1;
14008
14009   /* If this function is `main', emit a call to `__main'
14010      to run global initializers, etc.  */
14011   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
14012     expand_main_function ();
14013
14014   /* Now that we have initialized the parms, we can start their
14015      cleanups.  We cannot do this before, since expand_decl_cleanup
14016      should not be called before the parm can be used.  */
14017   while (cleanups)
14018     {
14019       finish_decl_cleanup (TREE_PURPOSE (cleanups),
14020                            TREE_VALUE (cleanups));
14021       cleanups = TREE_CHAIN (cleanups);
14022     }
14023
14024   /* Create a binding contour which can be used to catch
14025      cleanup-generated temporaries.  Also, if the return value needs or
14026      has initialization, deal with that now.  */
14027   if (parms_have_cleanups)
14028     {
14029       pushlevel (0);
14030       if (!building_stmt_tree ())
14031         expand_start_bindings (2);
14032     }
14033
14034   /* Do the starting of the exception specifications, if we have any.  */
14035   if (flag_exceptions && !processing_template_decl
14036       && flag_enforce_eh_specs
14037       && building_stmt_tree ()
14038       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14039     current_eh_spec_try_block = expand_start_eh_spec ();
14040 }
14041
14042 /* Bind a name and initialization to the return value of
14043    the current function.  */
14044
14045 void
14046 store_return_init (decl)
14047      tree decl;
14048 {
14049   /* If this named return value comes in a register, put it in a
14050      pseudo-register.  */
14051   if (DECL_REGISTER (decl))
14052     {
14053       original_result_rtx = DECL_RTL (decl);
14054       /* Note that the mode of the old DECL_RTL may be wider than the
14055          mode of DECL_RESULT, depending on the calling conventions for
14056          the processor.  For example, on the Alpha, a 32-bit integer
14057          is returned in a DImode register -- the DECL_RESULT has
14058          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
14059          here, we use the mode the back-end has already assigned for
14060          the return value.  */
14061       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
14062       if (TREE_ADDRESSABLE (decl))
14063         put_var_into_stack (decl);
14064     }
14065 }
14066
14067 \f
14068 /* We have finished doing semantic analysis on DECL, but have not yet
14069    generated RTL for its body.  Save away our current state, so that
14070    when we want to generate RTL later we know what to do.  */
14071
14072 static void
14073 save_function_data (decl)
14074      tree decl;
14075 {
14076   struct language_function *f;
14077
14078   /* Save the language-specific per-function data so that we can
14079      get it back when we really expand this function.  */
14080   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14081                       19990908);
14082
14083   /* Make a copy.  */
14084   f = ((struct language_function *)
14085        xmalloc (sizeof (struct language_function)));
14086   bcopy ((char *) cp_function_chain, (char *) f,
14087          sizeof (struct language_function));
14088   DECL_SAVED_FUNCTION_DATA (decl) = f;
14089
14090   /* Clear out the bits we don't need.  */
14091   f->x_base_init_list = NULL_TREE;
14092   f->x_member_init_list = NULL_TREE;
14093   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14094   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14095   f->x_result_rtx = NULL_RTX;
14096   f->x_named_label_uses = NULL;
14097   f->bindings = NULL;
14098
14099   /* When we get back here again, we will be expanding.  */
14100   f->x_expanding_p = 1;
14101
14102   /* If we've already decided that we cannot inline this function, we
14103      must remember that fact when we actually go to expand the
14104      function.  */
14105   f->cannot_inline = current_function_cannot_inline;
14106 }
14107
14108 /* At the end of every constructor we generate to code to return
14109    `this'.  Do that now.  */
14110
14111 static void
14112 finish_constructor_body ()
14113 {
14114   /* Any return from a constructor will end up here.  */
14115   if (ctor_label)
14116     add_tree (build_min_nt (LABEL_STMT, ctor_label));
14117
14118   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14119      generate the return, rather than a goto to CTOR_LABEL.  */
14120   ctor_label = NULL_TREE;
14121   /* In check_return_expr we translate an empty return from a
14122      constructor to a return of `this'.  */
14123   finish_return_stmt (NULL_TREE);
14124   /* Mark the end of the constructor.  */
14125   add_tree (build_min_nt (CTOR_STMT));
14126 }
14127
14128 /* At the end of every destructor we generate code to restore virtual
14129    function tables to the values desired by base classes and to call
14130    to base class destructors.  Do that now.  */
14131
14132 static void
14133 finish_destructor_body ()
14134 {
14135   tree compound_stmt;
14136   tree virtual_size;
14137   tree exprstmt;
14138   tree if_stmt;
14139
14140   /* Create a block to contain all the extra code.  */
14141   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14142
14143   /* Any return from a destructor will end up here.  */
14144   add_tree (build_min_nt (LABEL_STMT, dtor_label));
14145
14146   /* Generate the code to call destructor on base class.  If this
14147      destructor belongs to a class with virtual functions, then set
14148      the virtual function table pointer to represent the type of our
14149      base class.  */
14150
14151   /* This side-effect makes call to `build_delete' generate the code
14152      we have to have at the end of this destructor.  `build_delete'
14153      will set the flag again.  */
14154   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14155
14156   exprstmt = build_delete (current_class_type,
14157                            current_class_ref,
14158                            sfk_base_destructor,
14159                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14160                            0);
14161
14162   if (exprstmt != error_mark_node
14163       && (TREE_CODE (exprstmt) != NOP_EXPR
14164           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14165           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14166     {
14167       if (exprstmt != void_zero_node)
14168         /* Don't call `expand_expr_stmt' if we're not going to do
14169            anything, since -Wall will give a diagnostic.  */
14170         finish_expr_stmt (exprstmt);
14171
14172       /* Run destructors for all virtual baseclasses.  */
14173       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14174         {
14175           tree vbases;
14176           tree if_stmt;
14177
14178           if_stmt = begin_if_stmt ();
14179           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14180                                       current_in_charge_parm,
14181                                       integer_two_node),
14182                                if_stmt);
14183
14184           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14185           /* The CLASSTYPE_VBASECLASSES list is in initialization
14186              order, so we have to march through it in reverse order.  */
14187           for (vbases = nreverse (copy_list (vbases));
14188                vbases;
14189                vbases = TREE_CHAIN (vbases))
14190             {
14191               tree vbase = TREE_VALUE (vbases);
14192
14193               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14194                 {
14195                   tree vb = get_vbase
14196                     (BINFO_TYPE (vbase),
14197                      TYPE_BINFO (current_class_type));
14198                   finish_expr_stmt
14199                     (build_scoped_method_call
14200                      (current_class_ref, vb, base_dtor_identifier,
14201                       NULL_TREE));
14202                 }
14203             }
14204
14205           finish_then_clause (if_stmt);
14206           finish_if_stmt ();
14207         }
14208     }
14209
14210   virtual_size = c_sizeof (current_class_type);
14211
14212   /* At the end, call delete if that's what's requested.  */
14213
14214   /* FDIS sez: At the point of definition of a virtual destructor
14215      (including an implicit definition), non-placement operator delete
14216      shall be looked up in the scope of the destructor's class and if
14217      found shall be accessible and unambiguous.
14218
14219      This is somewhat unclear, but I take it to mean that if the class
14220      only defines placement deletes we don't do anything here.  So we
14221      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14222      they ever try to delete one of these.  */
14223   exprstmt = build_op_delete_call
14224     (DELETE_EXPR, current_class_ptr, virtual_size,
14225      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14226
14227   if_stmt = begin_if_stmt ();
14228   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14229                               current_in_charge_parm,
14230                               integer_one_node),
14231                        if_stmt);
14232   finish_expr_stmt (exprstmt);
14233   finish_then_clause (if_stmt);
14234   finish_if_stmt ();
14235
14236   /* Close the block we started above.  */
14237   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14238 }
14239
14240 /* Finish up a function declaration and compile that function
14241    all the way to assembler language output.  The free the storage
14242    for the function definition.
14243
14244    FLAGS is a bitwise or of the following values:
14245      1 - CALL_POPLEVEL
14246        An extra call to poplevel (and expand_end_bindings) must be
14247        made to take care of the binding contour for the base
14248        initializers.  This is only relevant for constructors.
14249      2 - INCLASS_INLINE
14250        We just finished processing the body of an in-class inline
14251        function definition.  (This processing will have taken place
14252        after the class definition is complete.)  */
14253
14254 tree
14255 finish_function (flags)
14256      int flags;
14257 {
14258   register tree fndecl = current_function_decl;
14259   tree fntype, ctype = NULL_TREE;
14260   /* Label to use if this function is supposed to return a value.  */
14261   tree no_return_label = NULL_TREE;
14262   int call_poplevel = (flags & 1) != 0;
14263   int inclass_inline = (flags & 2) != 0;
14264   int expand_p;
14265   int nested;
14266   int current_line = lineno;
14267
14268   /* When we get some parse errors, we can end up without a
14269      current_function_decl, so cope.  */
14270   if (fndecl == NULL_TREE)
14271     return error_mark_node;
14272
14273   nested = function_depth > 1;
14274   fntype = TREE_TYPE (fndecl);
14275
14276   /*  TREE_READONLY (fndecl) = 1;
14277       This caused &foo to be of type ptr-to-const-function
14278       which then got a warning when stored in a ptr-to-function variable.  */
14279
14280   /* This happens on strange parse errors.  */
14281   if (! current_function_parms_stored)
14282     {
14283       call_poplevel = 0;
14284       store_parm_decls ();
14285     }
14286
14287   /* For a cloned function, we've already got all the code we need;
14288      there's no need to add any extra bits.  */
14289   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14290     ;
14291   else if (building_stmt_tree ())
14292     {
14293       if (DECL_CONSTRUCTOR_P (fndecl))
14294         {
14295           finish_constructor_body ();
14296           if (call_poplevel)
14297             do_poplevel ();
14298         }
14299       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14300         finish_destructor_body ();
14301       else if (DECL_MAIN_P (fndecl))
14302         {
14303           /* Make it so that `main' always returns 0 by default.  */
14304 #ifdef VMS
14305           finish_return_stmt (integer_one_node);
14306 #else
14307           finish_return_stmt (integer_zero_node);
14308 #endif
14309         }
14310
14311       /* Finish dealing with exception specifiers.  */
14312       if (flag_exceptions && !processing_template_decl
14313           && flag_enforce_eh_specs
14314           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14315         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14316                             (TREE_TYPE (current_function_decl)),
14317                             current_eh_spec_try_block);
14318     }
14319   else
14320     {
14321 #if 0
14322       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14323         {
14324           /* Keep this code around in case we later want to control debug info
14325              based on whether a type is "used".  (jason 1999-11-11) */
14326
14327           tree ttype = target_type (fntype);
14328           tree parmdecl;
14329
14330           if (IS_AGGR_TYPE (ttype))
14331             /* Let debugger know it should output info for this type.  */
14332             note_debug_info_needed (ttype);
14333
14334           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14335             {
14336               ttype = target_type (TREE_TYPE (parmdecl));
14337               if (IS_AGGR_TYPE (ttype))
14338                 /* Let debugger know it should output info for this type.  */
14339                 note_debug_info_needed (ttype);
14340             }
14341         }
14342 #endif
14343
14344       /* Clean house because we will need to reorder insns here.  */
14345       do_pending_stack_adjust ();
14346
14347       if (dtor_label)
14348         ;
14349       else if (DECL_CONSTRUCTOR_P (fndecl))
14350         {
14351           if (call_poplevel)
14352             do_poplevel ();
14353         }
14354       else if (return_label != NULL_RTX
14355                && flag_this_is_variable <= 0
14356                && current_function_return_value == NULL_TREE
14357                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14358         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14359
14360       if (flag_exceptions)
14361         expand_exception_blocks ();
14362
14363       /* If this function is supposed to return a value, ensure that
14364          we do not fall into the cleanups by mistake.  The end of our
14365          function will look like this:
14366
14367          user code (may have return stmt somewhere)
14368          goto no_return_label
14369          cleanup_label:
14370          cleanups
14371          goto return_label
14372          no_return_label:
14373          NOTE_INSN_FUNCTION_END
14374          return_label:
14375          things for return
14376
14377          If the user omits a return stmt in the USER CODE section, we
14378          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14379          Otherwise, we won't.  */
14380       if (no_return_label)
14381         {
14382           DECL_CONTEXT (no_return_label) = fndecl;
14383           DECL_INITIAL (no_return_label) = error_mark_node;
14384           DECL_SOURCE_FILE (no_return_label) = input_filename;
14385           DECL_SOURCE_LINE (no_return_label) = current_line;
14386           expand_goto (no_return_label);
14387         }
14388
14389       if (cleanup_label)
14390         {
14391           /* Remove the binding contour which is used
14392              to catch cleanup-generated temporaries.  */
14393           expand_end_bindings (0, 0, 0);
14394           poplevel (0, 0, 0);
14395
14396           /* Emit label at beginning of cleanup code for parameters.  */
14397           emit_label (cleanup_label);
14398         }
14399
14400       /* Get return value into register if that's where it's supposed
14401          to be.  */
14402       if (original_result_rtx)
14403         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14404
14405       /* Finish building code that will trigger warnings if users forget
14406          to make their functions return values.  */
14407       if (no_return_label || cleanup_label)
14408         emit_jump (return_label);
14409       if (no_return_label)
14410         {
14411           /* We don't need to call `expand_*_return' here because we
14412              don't need any cleanups here--this path of code is only
14413              for error checking purposes.  */
14414           expand_label (no_return_label);
14415         }
14416
14417       /* We hard-wired immediate_size_expand to zero in
14418          start_function.  Expand_function_end will decrement this
14419          variable.  So, we set the variable to one here, so that after
14420          the decrement it will remain zero.  */
14421       immediate_size_expand = 1;
14422
14423       /* Generate rtl for function exit.  */
14424       expand_function_end (input_filename, current_line, 1);
14425     }
14426
14427   /* We have to save this value here in case
14428      maybe_end_member_template_processing decides to pop all the
14429      template parameters.  */
14430   expand_p = !building_stmt_tree ();
14431
14432   /* If we're saving up tree structure, tie off the function now.  */
14433   if (!expand_p)
14434     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14435
14436   /* This must come after expand_function_end because cleanups might
14437      have declarations (from inline functions) that need to go into
14438      this function's blocks.  */
14439   if (doing_semantic_analysis_p ())
14440     {
14441       if (current_binding_level->parm_flag != 1)
14442         my_friendly_abort (122);
14443       poplevel (1, 0, 1);
14444     }
14445
14446   /* Remember that we were in class scope.  */
14447   if (current_class_name)
14448     ctype = current_class_type;
14449
14450   /* Must mark the RESULT_DECL as being in this function.  */
14451   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14452
14453   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14454      to the FUNCTION_DECL node itself.  */
14455   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14456
14457   /* Save away current state, if appropriate.  */
14458   if (!expanding_p && !processing_template_decl)
14459     save_function_data (fndecl);
14460
14461   /* If this function calls `setjmp' it cannot be inlined.  When
14462      `longjmp' is called it is not guaranteed to restore the value of
14463      local variables that have been modified since the call to
14464      `setjmp'.  So, if were to inline this function into some caller
14465      `c', then when we `longjmp', we might not restore all variables
14466      in `c'.  (It might seem, at first blush, that there's no way for
14467      this function to modify local variables in `c', but their
14468      addresses may have been stored somewhere accessible to this
14469      function.)  */
14470   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14471     DECL_UNINLINABLE (fndecl) = 1;
14472
14473   if (expand_p)
14474     {
14475       int returns_null;
14476       int returns_value;
14477
14478       /* So we can tell if jump_optimize sets it to 1.  */
14479       can_reach_end = 0;
14480
14481       /* Before we call rest_of_compilation (which will pop the
14482          CURRENT_FUNCTION), we must save these values.  */
14483       returns_null = current_function_returns_null;
14484       returns_value = current_function_returns_value;
14485
14486       /* If this is a nested function (like a template instantiation
14487          that we're compiling in the midst of compiling something
14488          else), push a new GC context.  That will keep local variables
14489          on the stack from being collected while we're doing the
14490          compilation of this function.  */
14491       if (function_depth > 1)
14492         ggc_push_context ();
14493
14494       /* Run the optimizers and output the assembler code for this
14495          function.  */
14496       rest_of_compilation (fndecl);
14497
14498       /* Undo the call to ggc_push_context above.  */
14499       if (function_depth > 1)
14500         ggc_pop_context ();
14501
14502       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14503         {
14504           /* Set DECL_EXTERNAL so that assemble_external will be called as
14505              necessary.  We'll clear it again in finish_file.  */
14506           if (! DECL_EXTERNAL (fndecl))
14507             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14508           DECL_EXTERNAL (fndecl) = 1;
14509           defer_fn (fndecl);
14510         }
14511
14512 #if 0
14513       /* Keep this code around in case we later want to control debug info
14514          based on whether a type is "used".  (jason 1999-11-11) */
14515
14516       if (ctype && TREE_ASM_WRITTEN (fndecl))
14517         note_debug_info_needed (ctype);
14518 #endif
14519
14520       returns_null |= can_reach_end;
14521
14522       /* Since we don't normally go through c_expand_return for constructors,
14523          this normally gets the wrong value.
14524          Also, named return values have their return codes emitted after
14525          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
14526       if (DECL_CONSTRUCTOR_P (fndecl)
14527           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
14528         returns_null = 0;
14529
14530       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14531         cp_warning ("`noreturn' function `%D' does return", fndecl);
14532       else if ((warn_return_type || pedantic)
14533                && returns_null
14534                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14535         {
14536           /* If this function returns non-void and control can drop through,
14537              complain.  */
14538           cp_warning ("control reaches end of non-void function `%D'", fndecl);
14539         }
14540       /* With just -W, complain only if function returns both with
14541          and without a value.  */
14542       else if (extra_warnings && returns_value && returns_null)
14543         warning ("this function may return with or without a value");
14544     }
14545   else
14546     {
14547       /* Clear out memory we no longer need.  */
14548       free_after_parsing (cfun);
14549       /* Since we never call rest_of_compilation, we never clear
14550          CFUN.  Do so explicitly.  */
14551       free_after_compilation (cfun);
14552       cfun = NULL;
14553     }
14554
14555   /* If this is a in-class inline definition, we may have to pop the
14556      bindings for the template parameters that we added in
14557      maybe_begin_member_template_processing when start_function was
14558      called.  */
14559   if (inclass_inline)
14560     maybe_end_member_template_processing ();
14561
14562   /* Leave the scope of the class.  */
14563   if (ctype)
14564     pop_nested_class ();
14565
14566   --function_depth;
14567
14568   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14569       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14570     {
14571       tree t;
14572
14573       /* Stop pointing to the local nodes about to be freed.  */
14574       /* But DECL_INITIAL must remain nonzero so we know this
14575          was an actual function definition.  */
14576       DECL_INITIAL (fndecl) = error_mark_node;
14577       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14578         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14579     }
14580
14581   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14582     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14583   if (DECL_STATIC_DESTRUCTOR (fndecl))
14584     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14585
14586   /* Clean up.  */
14587   if (! nested)
14588     {
14589       /* Let the error reporting routines know that we're outside a
14590          function.  For a nested function, this value is used in
14591          pop_cp_function_context and then reset via pop_function_context.  */
14592       current_function_decl = NULL_TREE;
14593       /* We don't really care about obstacks, but the middle-end
14594          sometimes cares on what obstck things are located.  */
14595       permanent_allocation (1);
14596     }
14597
14598   return fndecl;
14599 }
14600 \f
14601 /* Create the FUNCTION_DECL for a function definition.
14602    DECLSPECS and DECLARATOR are the parts of the declaration;
14603    they describe the return type and the name of the function,
14604    but twisted together in a fashion that parallels the syntax of C.
14605
14606    This function creates a binding context for the function body
14607    as well as setting up the FUNCTION_DECL in current_function_decl.
14608
14609    Returns a FUNCTION_DECL on success.
14610
14611    If the DECLARATOR is not suitable for a function (it defines a datum
14612    instead), we return 0, which tells yyparse to report a parse error.
14613
14614    May return void_type_node indicating that this method is actually
14615    a friend.  See grokfield for more details.
14616
14617    Came here with a `.pushlevel' .
14618
14619    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14620    CHANGES TO CODE IN `grokfield'.  */
14621
14622 tree
14623 start_method (declspecs, declarator, attrlist)
14624      tree declarator, declspecs, attrlist;
14625 {
14626   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14627                                 attrlist);
14628
14629   /* Something too ugly to handle.  */
14630   if (fndecl == NULL_TREE)
14631     return NULL_TREE;
14632
14633   /* Pass friends other than inline friend functions back.  */
14634   if (fndecl == void_type_node)
14635     return fndecl;
14636
14637   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14638     /* Not a function, tell parser to report parse error.  */
14639     return NULL_TREE;
14640
14641   if (DECL_IN_AGGR_P (fndecl))
14642     {
14643       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14644         {
14645           if (DECL_CONTEXT (fndecl)
14646               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14647             cp_error ("`%D' is already defined in class %s", fndecl,
14648                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14649         }
14650       return void_type_node;
14651     }
14652
14653   check_template_shadow (fndecl);
14654
14655   DECL_THIS_INLINE (fndecl) = 1;
14656
14657   if (flag_default_inline)
14658     DECL_INLINE (fndecl) = 1;
14659
14660   /* We process method specializations in finish_struct_1.  */
14661   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14662     fndecl = push_template_decl (fndecl);
14663
14664   if (! DECL_FRIEND_P (fndecl))
14665     {
14666       if (TREE_CHAIN (fndecl))
14667         {
14668           fndecl = copy_node (fndecl);
14669           TREE_CHAIN (fndecl) = NULL_TREE;
14670         }
14671
14672       if (DECL_CONSTRUCTOR_P (fndecl))
14673         {
14674           if (! grok_ctor_properties (current_class_type, fndecl))
14675             return void_type_node;
14676         }
14677       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14678         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14679     }
14680
14681   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14682
14683   /* Make a place for the parms */
14684   pushlevel (0);
14685   current_binding_level->parm_flag = 1;
14686
14687   DECL_IN_AGGR_P (fndecl) = 1;
14688   return fndecl;
14689 }
14690
14691 /* Go through the motions of finishing a function definition.
14692    We don't compile this method until after the whole class has
14693    been processed.
14694
14695    FINISH_METHOD must return something that looks as though it
14696    came from GROKFIELD (since we are defining a method, after all).
14697
14698    This is called after parsing the body of the function definition.
14699    STMTS is the chain of statements that makes up the function body.
14700
14701    DECL is the ..._DECL that `start_method' provided.  */
14702
14703 tree
14704 finish_method (decl)
14705      tree decl;
14706 {
14707   register tree fndecl = decl;
14708   tree old_initial;
14709
14710   register tree link;
14711
14712   if (decl == void_type_node)
14713     return decl;
14714
14715   old_initial = DECL_INITIAL (fndecl);
14716
14717   /* Undo the level for the parms (from start_method).
14718      This is like poplevel, but it causes nothing to be
14719      saved.  Saving information here confuses symbol-table
14720      output routines.  Besides, this information will
14721      be correctly output when this method is actually
14722      compiled.  */
14723
14724   /* Clear out the meanings of the local variables of this level;
14725      also record in each decl which block it belongs to.  */
14726
14727   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14728     {
14729       if (DECL_NAME (link) != NULL_TREE)
14730         pop_binding (DECL_NAME (link), link);
14731       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14732       DECL_CONTEXT (link) = NULL_TREE;
14733     }
14734
14735   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14736                       (HOST_WIDE_INT) current_binding_level->level_chain,
14737                       current_binding_level->parm_flag,
14738                       current_binding_level->keep);
14739
14740   poplevel (0, 0, 0);
14741
14742   DECL_INITIAL (fndecl) = old_initial;
14743
14744   /* We used to check if the context of FNDECL was different from
14745      current_class_type as another way to get inside here.  This didn't work
14746      for String.cc in libg++.  */
14747   if (DECL_FRIEND_P (fndecl))
14748     {
14749       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14750         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14751       decl = void_type_node;
14752     }
14753
14754   return decl;
14755 }
14756 \f
14757 /* Called when a new struct TYPE is defined.
14758    If this structure or union completes the type of any previous
14759    variable declaration, lay it out and output its rtl.  */
14760
14761 void
14762 hack_incomplete_structures (type)
14763      tree type;
14764 {
14765   tree *list;
14766   struct binding_level *level;
14767
14768   if (!type) /* Don't do this for class templates.  */
14769     return;
14770
14771   if (namespace_bindings_p ())
14772     {
14773       level = 0;
14774       list = &namespace_scope_incomplete;
14775     }
14776   else
14777     {
14778       level = innermost_nonclass_level ();
14779       list = &level->incomplete;
14780     }
14781
14782   while (1)
14783     {
14784       while (*list)
14785         {
14786           tree decl = TREE_VALUE (*list);
14787           if ((decl && TREE_TYPE (decl) == type)
14788               || (TREE_TYPE (decl)
14789                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14790                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14791             {
14792               int toplevel = toplevel_bindings_p ();
14793               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14794                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14795                 layout_type (TREE_TYPE (decl));
14796               layout_decl (decl, 0);
14797               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14798               if (! toplevel)
14799                 {
14800                   tree cleanup;
14801                   expand_decl (decl);
14802                   cleanup = maybe_build_cleanup (decl);
14803                   expand_decl_init (decl);
14804                   if (! expand_decl_cleanup (decl, cleanup))
14805                     cp_error ("parser lost in parsing declaration of `%D'",
14806                               decl);
14807                 }
14808               *list = TREE_CHAIN (*list);
14809             }
14810           else
14811             list = &TREE_CHAIN (*list);
14812         }
14813
14814       /* Keep looking through artificial binding levels generated
14815          for local variables.  */
14816       if (level && level->keep == 2)
14817         {
14818           level = level->level_chain;
14819           list = &level->incomplete;
14820         }
14821       else
14822         break;
14823     }
14824 }
14825
14826 /* If DECL is of a type which needs a cleanup, build that cleanup
14827    here.  */
14828
14829 tree
14830 maybe_build_cleanup (decl)
14831      tree decl;
14832 {
14833   tree type = TREE_TYPE (decl);
14834
14835   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14836     {
14837       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14838       tree rval;
14839
14840       if (TREE_CODE (type) == ARRAY_TYPE)
14841         rval = decl;
14842       else
14843         {
14844           mark_addressable (decl);
14845           rval = build_unary_op (ADDR_EXPR, decl, 0);
14846         }
14847
14848       /* Optimize for space over speed here.  */
14849       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14850           || flag_expensive_optimizations)
14851         flags |= LOOKUP_NONVIRTUAL;
14852
14853       rval = build_delete (TREE_TYPE (rval), rval,
14854                            sfk_complete_destructor, flags, 0);
14855
14856       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14857           && ! TYPE_HAS_DESTRUCTOR (type))
14858         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14859                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14860
14861       return rval;
14862     }
14863   return 0;
14864 }
14865 \f
14866 /* Expand a C++ expression at the statement level.
14867    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14868    The C++ type checker should get all of these out when
14869    expressions are combined with other, type-providing, expressions,
14870    leaving only orphan expressions, such as:
14871
14872    &class::bar;         / / takes its address, but does nothing with it.  */
14873
14874 void
14875 cplus_expand_expr_stmt (exp)
14876      tree exp;
14877 {
14878 #if 0
14879   /* We should do this eventually, but right now this causes regex.o from
14880      libg++ to miscompile, and tString to core dump.  */
14881   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14882 #endif
14883
14884   /* If we don't do this, we end up down inside expand_expr
14885      trying to do TYPE_MODE on the ERROR_MARK, and really
14886      go outside the bounds of the type.  */
14887   if (exp != error_mark_node)
14888     expand_expr_stmt (exp);
14889 }
14890
14891 /* When a stmt has been parsed, this function is called.  */
14892
14893 void
14894 finish_stmt ()
14895 {
14896   /* Always assume this statement was not an expression statement.  If
14897      it actually was an expression statement, its our callers
14898      responsibility to fix this up.  */
14899   last_expr_type = NULL_TREE;
14900 }
14901
14902 /* DECL was originally constructed as a non-static member function,
14903    but turned out to be static.  Update it accordingly.  */
14904
14905 void
14906 revert_static_member_fn (decl)
14907      tree decl;
14908 {
14909   tree tmp;
14910   tree function = TREE_TYPE (decl);
14911   tree args = TYPE_ARG_TYPES (function);
14912
14913   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14914       != TYPE_UNQUALIFIED)
14915     cp_error ("static member function `%#D' declared with type qualifiers",
14916               *decl);
14917
14918   args = TREE_CHAIN (args);
14919   tmp = build_function_type (TREE_TYPE (function), args);
14920   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14921   tmp = build_exception_variant (tmp,
14922                                  TYPE_RAISES_EXCEPTIONS (function));
14923   TREE_TYPE (decl) = tmp;
14924   if (DECL_ARGUMENTS (decl))
14925     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14926   DECL_STATIC_FUNCTION_P (decl) = 1;
14927 }
14928
14929 /* Initialize the variables used during compilation of a C++
14930    function.  */
14931
14932 static void
14933 push_cp_function_context (f)
14934      struct function *f;
14935 {
14936   struct language_function *p
14937     = ((struct language_function *)
14938        xcalloc (1, sizeof (struct language_function)));
14939   f->language = p;
14940
14941   /* It takes an explicit call to expand_body to generate RTL for a
14942      function.  */
14943   expanding_p = 0;
14944
14945   /* Whenever we start a new function, we destroy temporaries in the
14946      usual way.  */
14947   stmts_are_full_exprs_p = 1;
14948 }
14949
14950 /* Free the language-specific parts of F, now that we've finished
14951    compiling the function.  */
14952
14953 static void
14954 pop_cp_function_context (f)
14955      struct function *f;
14956 {
14957   if (f->language)
14958     free (f->language);
14959   f->language = 0;
14960 }
14961
14962 /* Mark P for GC.  */
14963
14964 static void
14965 mark_lang_function (p)
14966      struct language_function *p;
14967 {
14968   if (!p)
14969     return;
14970
14971   ggc_mark_tree (p->x_ctor_label);
14972   ggc_mark_tree (p->x_dtor_label);
14973   ggc_mark_tree (p->x_base_init_list);
14974   ggc_mark_tree (p->x_member_init_list);
14975   ggc_mark_tree (p->x_current_class_ptr);
14976   ggc_mark_tree (p->x_current_class_ref);
14977   ggc_mark_tree (p->x_eh_spec_try_block);
14978   ggc_mark_tree (p->x_scope_stmt_stack);
14979
14980   ggc_mark_rtx (p->x_result_rtx);
14981
14982   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14983   mark_stmt_tree (&p->x_stmt_tree);
14984   mark_binding_level (&p->bindings);
14985 }
14986
14987 /* Mark the language-specific data in F for GC.  */
14988
14989 static void
14990 mark_cp_function_context (f)
14991      struct function *f;
14992 {
14993   mark_lang_function (f->language);
14994 }
14995
14996 void
14997 lang_mark_false_label_stack (l)
14998      struct label_node *l;
14999 {
15000   /* C++ doesn't use false_label_stack.  It better be NULL.  */
15001   my_friendly_assert (l == NULL, 19990904);
15002 }
15003
15004 void
15005 lang_mark_tree (t)
15006      tree t;
15007 {
15008   enum tree_code code = TREE_CODE (t);
15009   if (code == IDENTIFIER_NODE)
15010     {
15011       struct lang_identifier *li = (struct lang_identifier *) t;
15012       struct lang_id2 *li2 = li->x;
15013       ggc_mark_tree (li->namespace_bindings);
15014       ggc_mark_tree (li->bindings);
15015       ggc_mark_tree (li->class_value);
15016       ggc_mark_tree (li->class_template_info);
15017
15018       if (li2)
15019         {
15020           ggc_mark_tree (li2->label_value);
15021           ggc_mark_tree (li2->implicit_decl);
15022           ggc_mark_tree (li2->error_locus);
15023         }
15024     }
15025   else if (code == CPLUS_BINDING)
15026     {
15027       if (BINDING_HAS_LEVEL_P (t))
15028         mark_binding_level (&BINDING_LEVEL (t));
15029       else
15030         ggc_mark_tree (BINDING_SCOPE (t));
15031       ggc_mark_tree (BINDING_VALUE (t));
15032     }
15033   else if (code == OVERLOAD)
15034     ggc_mark_tree (OVL_FUNCTION (t));
15035   else if (code == TEMPLATE_PARM_INDEX)
15036     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
15037   else if (TREE_CODE_CLASS (code) == 'd')
15038     {
15039       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
15040
15041       if (ld)
15042         {
15043           ggc_mark (ld);
15044           if (!DECL_GLOBAL_CTOR_P (t)
15045               && !DECL_GLOBAL_DTOR_P (t)
15046               && !DECL_THUNK_P (t))
15047             ggc_mark_tree (ld->decl_flags.u2.access);
15048           ggc_mark_tree (ld->decl_flags.context);
15049           if (TREE_CODE (t) != NAMESPACE_DECL)
15050             ggc_mark_tree (ld->decl_flags.u.template_info);
15051           else
15052             mark_binding_level (&NAMESPACE_LEVEL (t));
15053           if (CAN_HAVE_FULL_LANG_DECL_P (t))
15054             {
15055               ggc_mark_tree (ld->befriending_classes);
15056               ggc_mark_tree (ld->saved_tree);
15057               ggc_mark_tree (ld->cloned_function);
15058               if (!DECL_OVERLOADED_OPERATOR_P (t))
15059                 ggc_mark_tree (ld->u2.vtt_parm);
15060               if (TREE_CODE (t) == TYPE_DECL)
15061                 ggc_mark_tree (ld->u.sorted_fields);
15062               else if (TREE_CODE (t) == FUNCTION_DECL
15063                        && !DECL_PENDING_INLINE_P (t))
15064                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
15065             }
15066         }
15067     }
15068   else if (TREE_CODE_CLASS (code) == 't')
15069     {
15070       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
15071
15072       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15073                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15074         {
15075           ggc_mark (lt);
15076           ggc_mark_tree (lt->vfields);
15077           ggc_mark_tree (lt->vbases);
15078           ggc_mark_tree (lt->tags);
15079           ggc_mark_tree (lt->size);
15080           ggc_mark_tree (lt->pure_virtuals);
15081           ggc_mark_tree (lt->friend_classes);
15082           ggc_mark_tree (lt->rtti);
15083           ggc_mark_tree (lt->methods);
15084           ggc_mark_tree (lt->template_info);
15085           ggc_mark_tree (lt->befriending_classes);
15086         }
15087       else if (lt)
15088         /* In the case of pointer-to-member function types, the
15089            TYPE_LANG_SPECIFIC is really just a tree.  */
15090         ggc_mark_tree ((tree) lt);
15091     }
15092 }