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   /* There can be two block-scope declarations of the same variable,
1036      so long as they are `extern' declarations.  */
1037   else if (TREE_CODE (decl) == VAR_DECL
1038            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1039            && DECL_EXTERNAL (decl)
1040            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1041     {
1042       duplicate_decls (decl, BINDING_VALUE (binding));
1043       ok = 0;
1044     }
1045   else
1046     {
1047       cp_error ("declaration of `%#D'", decl);
1048       cp_error_at ("conflicts with previous declaration `%#D'",
1049                    BINDING_VALUE (binding));
1050       ok = 0;
1051     }
1052
1053   return ok;
1054 }
1055
1056 /* Add DECL to the list of things declared in B.  */
1057
1058 static void
1059 add_decl_to_level (decl, b)
1060      tree decl;
1061      struct binding_level *b;
1062 {
1063   /* We build up the list in reverse order, and reverse it later if
1064      necessary.  */
1065   TREE_CHAIN (decl) = b->names;
1066   b->names = decl;
1067 }
1068
1069 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1070    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1071    doesn't really belong to this binding level, that it got here
1072    through a using-declaration.  */
1073
1074 void
1075 push_local_binding (id, decl, flags)
1076      tree id;
1077      tree decl;
1078      int flags;
1079 {
1080   struct binding_level *b;
1081
1082   /* Skip over any local classes.  This makes sense if we call
1083      push_local_binding with a friend decl of a local class.  */
1084   b = current_binding_level;
1085   while (b->parm_flag == 2)
1086     b = b->level_chain;
1087
1088   if (lookup_name_current_level (id))
1089     {
1090       /* Supplement the existing binding.  */
1091       if (!add_binding (id, decl))
1092         /* It didn't work.  Something else must be bound at this
1093            level.  Do not add DECL to the list of things to pop
1094            later.  */
1095         return;
1096     }
1097   else
1098     /* Create a new binding.  */
1099     push_binding (id, decl, b);
1100
1101   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1102     /* We must put the OVERLOAD into a TREE_LIST since the
1103        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1104        decls that got here through a using-declaration.  */
1105     decl = build_tree_list (NULL_TREE, decl);
1106
1107   /* And put DECL on the list of things declared by the current
1108      binding level.  */
1109   add_decl_to_level (decl, b);
1110 }
1111
1112 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1113    binding was successful.  */
1114
1115 int
1116 push_class_binding (id, decl)
1117      tree id;
1118      tree decl;
1119 {
1120   int result = 1;
1121   tree binding = IDENTIFIER_BINDING (id);
1122   tree context;
1123
1124   /* Note that we declared this value so that we can issue an error if
1125      this an illegal redeclaration of a name already used for some
1126      other purpose.  */
1127   note_name_declared_in_class (id, decl);
1128
1129   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1130     /* Supplement the existing binding.  */
1131     result = add_binding (id, decl);
1132   else
1133     /* Create a new binding.  */
1134     push_binding (id, decl, class_binding_level);
1135
1136   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1137      class-level declaration.  Note that we do not use DECL here
1138      because of the possibility of the `struct stat' hack; if DECL is
1139      a class-name or enum-name we might prefer a field-name, or some
1140      such.  */
1141   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1142
1143   /* If this is a binding from a base class, mark it as such.  */
1144   binding = IDENTIFIER_BINDING (id);
1145   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1146     {
1147       /* Any implicit typename must be from a base-class.  The
1148          context for an implicit typename declaration is always
1149          the derived class in which the lookup was done, so the checks
1150          based on the context of DECL below will not trigger.  */
1151       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1152         INHERITED_VALUE_BINDING_P (binding) = 1;
1153       else
1154         {
1155           if (TREE_CODE (decl) == OVERLOAD)
1156             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1157           else
1158             {
1159               my_friendly_assert (DECL_P (decl), 0);
1160               context = CP_DECL_CONTEXT (decl);
1161             }
1162
1163           if (is_properly_derived_from (current_class_type, context))
1164             INHERITED_VALUE_BINDING_P (binding) = 1;
1165           else
1166             INHERITED_VALUE_BINDING_P (binding) = 0;
1167         }
1168     }
1169   else if (BINDING_VALUE (binding) == decl)
1170     /* We only encounter a TREE_LIST when push_class_decls detects an
1171        ambiguity.  Such an ambiguity can be overridden by a definition
1172        in this class.  */
1173     INHERITED_VALUE_BINDING_P (binding) = 1;
1174
1175   return result;
1176 }
1177
1178 /* Remove the binding for DECL which should be the innermost binding
1179    for ID.  */
1180
1181 static void
1182 pop_binding (id, decl)
1183      tree id;
1184      tree decl;
1185 {
1186   tree binding;
1187
1188   if (id == NULL_TREE)
1189     /* It's easiest to write the loops that call this function without
1190        checking whether or not the entities involved have names.  We
1191        get here for such an entity.  */
1192     return;
1193
1194   /* Get the innermost binding for ID.  */
1195   binding = IDENTIFIER_BINDING (id);
1196
1197   /* The name should be bound.  */
1198   my_friendly_assert (binding != NULL_TREE, 0);
1199
1200   /* The DECL will be either the ordinary binding or the type
1201      binding for this identifier.  Remove that binding.  */
1202   if (BINDING_VALUE (binding) == decl)
1203     BINDING_VALUE (binding) = NULL_TREE;
1204   else if (BINDING_TYPE (binding) == decl)
1205     BINDING_TYPE (binding) = NULL_TREE;
1206   else
1207     my_friendly_abort (0);
1208
1209   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1210     /* We're completely done with the innermost binding for this
1211        identifier.  Unhook it from the list of bindings.  */
1212     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1213 }
1214
1215 /* When a label goes out of scope, check to see if that label was used
1216    in a valid manner, and issue any appropriate warnings or errors.  */
1217
1218 static void
1219 pop_label (label, old_value)
1220      tree label;
1221      tree old_value;
1222 {
1223   if (!processing_template_decl && doing_semantic_analysis_p ())
1224     {
1225       if (DECL_INITIAL (label) == NULL_TREE)
1226         {
1227           cp_error_at ("label `%D' used but not defined", label);
1228           /* Avoid crashing later.  */
1229           define_label (input_filename, 1, DECL_NAME (label));
1230         }
1231       else if (warn_unused_label && !TREE_USED (label))
1232         cp_warning_at ("label `%D' defined but not used", label);
1233     }
1234
1235   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1236 }
1237
1238 /* At the end of a function, all labels declared within the fucntion
1239    go out of scope.  BLOCK is the top-level block for the
1240    function.  */
1241
1242 static void
1243 pop_labels (block)
1244      tree block;
1245 {
1246   struct named_label_list *link;
1247
1248   /* Clear out the definitions of all label names, since their scopes
1249      end here.  */
1250   for (link = named_labels; link; link = link->next)
1251     {
1252       pop_label (link->label_decl, link->old_value);
1253       /* Put the labels into the "variables" of the top-level block,
1254          so debugger can see them.  */
1255       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1256       BLOCK_VARS (block) = link->label_decl;
1257     }
1258
1259   named_labels = NULL;
1260 }
1261
1262 /* Exit a binding level.
1263    Pop the level off, and restore the state of the identifier-decl mappings
1264    that were in effect when this level was entered.
1265
1266    If KEEP == 1, this level had explicit declarations, so
1267    and create a "block" (a BLOCK node) for the level
1268    to record its declarations and subblocks for symbol table output.
1269
1270    If FUNCTIONBODY is nonzero, this level is the body of a function,
1271    so create a block as if KEEP were set and also clear out all
1272    label names.
1273
1274    If REVERSE is nonzero, reverse the order of decls before putting
1275    them into the BLOCK.  */
1276
1277 tree
1278 poplevel (keep, reverse, functionbody)
1279      int keep;
1280      int reverse;
1281      int functionbody;
1282 {
1283   register tree link;
1284   /* The chain of decls was accumulated in reverse order.
1285      Put it into forward order, just for cleanliness.  */
1286   tree decls;
1287   int tmp = functionbody;
1288   int real_functionbody;
1289   tree tags;
1290   tree subblocks;
1291   tree block = NULL_TREE;
1292   tree decl;
1293   int block_previously_created;
1294   int leaving_for_scope;
1295
1296   if (cfun && !doing_semantic_analysis_p ())
1297     return NULL_TREE;
1298
1299   my_friendly_assert (current_binding_level->parm_flag != 2,
1300                       19990916);
1301
1302   real_functionbody = (current_binding_level->keep == 2
1303                        ? ((functionbody = 0), tmp) : functionbody);
1304   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1305   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1306
1307   my_friendly_assert (!current_binding_level->class_shadowed,
1308                       19990414);
1309
1310   /* We used to use KEEP == 2 to indicate that the new block should go
1311      at the beginning of the list of blocks at this binding level,
1312      rather than the end.  This hack is no longer used.  */
1313   my_friendly_assert (keep == 0 || keep == 1, 0);
1314
1315   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1316                       (HOST_WIDE_INT) current_binding_level->level_chain,
1317                       current_binding_level->parm_flag,
1318                       current_binding_level->keep);
1319
1320   if (current_binding_level->keep == 1)
1321     keep = 1;
1322
1323   /* Any uses of undefined labels, and any defined labels, now operate
1324      under constraints of next binding contour.  */
1325   if (cfun && !functionbody)
1326     {
1327       struct binding_level *level_chain;
1328       level_chain = current_binding_level->level_chain;
1329       if (level_chain)
1330         {
1331           struct named_label_use_list *uses;
1332           struct named_label_list *labels;
1333           for (labels = named_labels; labels; labels = labels->next)
1334             if (labels->binding_level == current_binding_level)
1335               {
1336                 tree decl;
1337                 if (current_binding_level->eh_region)
1338                   labels->eh_region = 1;
1339                 for (decl = labels->names_in_scope; decl;
1340                      decl = TREE_CHAIN (decl))
1341                   if (decl_jump_unsafe (decl))
1342                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1343                                                    labels->bad_decls);
1344                 labels->binding_level = level_chain;
1345                 labels->names_in_scope = level_chain->names;
1346               }
1347
1348           for (uses = named_label_uses; uses; uses = uses->next)
1349             if (uses->binding_level == current_binding_level)
1350               {
1351                 uses->binding_level = level_chain;
1352                 uses->names_in_scope = level_chain->names;
1353               }
1354         }
1355     }
1356
1357   /* Get the decls in the order they were written.
1358      Usually current_binding_level->names is in reverse order.
1359      But parameter decls were previously put in forward order.  */
1360
1361   if (reverse)
1362     current_binding_level->names
1363       = decls = nreverse (current_binding_level->names);
1364   else
1365     decls = current_binding_level->names;
1366
1367   /* Output any nested inline functions within this block
1368      if they weren't already output.  */
1369   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1370     if (TREE_CODE (decl) == FUNCTION_DECL
1371         && ! TREE_ASM_WRITTEN (decl)
1372         && DECL_INITIAL (decl) != NULL_TREE
1373         && TREE_ADDRESSABLE (decl)
1374         && decl_function_context (decl) == current_function_decl)
1375       {
1376         /* If this decl was copied from a file-scope decl
1377            on account of a block-scope extern decl,
1378            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1379         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1380           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1381         else
1382           {
1383             push_function_context ();
1384             output_inline_function (decl);
1385             pop_function_context ();
1386           }
1387       }
1388
1389   /* When not in function-at-a-time mode, expand_end_bindings will
1390      warn about unused variables.  But, in function-at-a-time mode
1391      expand_end_bindings is not passed the list of variables in the
1392      current scope, and therefore no warning is emitted.  So, we
1393      explicitly warn here.  */
1394   if (!processing_template_decl)
1395     warn_about_unused_variables (getdecls ());
1396
1397   /* If there were any declarations or structure tags in that level,
1398      or if this level is a function body,
1399      create a BLOCK to record them for the life of this function.  */
1400   block = NULL_TREE;
1401   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1402   if (block_previously_created)
1403     block = current_binding_level->this_block;
1404   else if (keep == 1 || functionbody)
1405     block = make_node (BLOCK);
1406   if (block != NULL_TREE)
1407     {
1408       if (block_previously_created)
1409         {
1410           if (decls || tags || subblocks)
1411             {
1412               if (BLOCK_VARS (block))
1413                 warning ("internal compiler error: debugging info corrupted");
1414
1415               BLOCK_VARS (block) = decls;
1416
1417               /* We can have previous subblocks and new subblocks when
1418                  doing fixup_gotos with complex cleanups.  We chain the new
1419                  subblocks onto the end of any pre-existing subblocks.  */
1420               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1421                                                  subblocks);
1422             }
1423         }
1424       else
1425         {
1426           BLOCK_VARS (block) = decls;
1427           BLOCK_SUBBLOCKS (block) = subblocks;
1428         }
1429     }
1430
1431   /* In each subblock, record that this is its superior.  */
1432   if (keep >= 0)
1433     for (link = subblocks; link; link = TREE_CHAIN (link))
1434       BLOCK_SUPERCONTEXT (link) = block;
1435
1436   /* We still support the old for-scope rules, whereby the variables
1437      in a for-init statement were in scope after the for-statement
1438      ended.  We only use the new rules in flag_new_for_scope is
1439      nonzero.  */
1440   leaving_for_scope
1441     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1442
1443   /* Remove declarations for all the DECLs in this level.  */
1444   for (link = decls; link; link = TREE_CHAIN (link))
1445     {
1446       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1447         {
1448           tree outer_binding
1449             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1450           tree ns_binding;
1451
1452           if (!outer_binding)
1453             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1454           else
1455             ns_binding = NULL_TREE;
1456
1457           if (outer_binding
1458               && (BINDING_LEVEL (outer_binding)
1459                   == current_binding_level->level_chain))
1460             /* We have something like:
1461
1462                  int i;
1463                  for (int i; ;);
1464
1465                and we are leaving the `for' scope.  There's no reason to
1466                keep the binding of the inner `i' in this case.  */
1467             pop_binding (DECL_NAME (link), link);
1468           else if ((outer_binding
1469                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1470                         == TYPE_DECL))
1471                    || (ns_binding
1472                        && TREE_CODE (ns_binding) == TYPE_DECL))
1473             /* Here, we have something like:
1474
1475                  typedef int I;
1476
1477                  void f () {
1478                    for (int I; ;);
1479                  }
1480
1481                We must pop the for-scope binding so we know what's a
1482                type and what isn't.  */
1483             pop_binding (DECL_NAME (link), link);
1484           else
1485             {
1486               /* Mark this VAR_DECL as dead so that we can tell we left it
1487                  there only for backward compatibility.  */
1488               DECL_DEAD_FOR_LOCAL (link) = 1;
1489
1490               /* Keep track of what should of have happenned when we
1491                  popped the binding.  */
1492               if (outer_binding && BINDING_VALUE (outer_binding))
1493                 DECL_SHADOWED_FOR_VAR (link)
1494                   = BINDING_VALUE (outer_binding);
1495
1496               /* Add it to the list of dead variables in the next
1497                  outermost binding to that we can remove these when we
1498                  leave that binding.  */
1499               current_binding_level->level_chain->dead_vars_from_for
1500                 = tree_cons (NULL_TREE, link,
1501                              current_binding_level->level_chain->
1502                              dead_vars_from_for);
1503
1504               /* Although we don't pop the CPLUS_BINDING, we do clear
1505                  its BINDING_LEVEL since the level is going away now.  */
1506               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1507                 = 0;
1508             }
1509         }
1510       else
1511         {
1512           /* Remove the binding.  */
1513           decl = link;
1514           if (TREE_CODE (decl) == TREE_LIST)
1515             decl = TREE_VALUE (decl);
1516           if (DECL_P (decl))
1517             pop_binding (DECL_NAME (decl), decl);
1518           else if (TREE_CODE (decl) == OVERLOAD)
1519             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1520           else
1521             my_friendly_abort (0);
1522         }
1523     }
1524
1525   /* Remove declarations for any `for' variables from inner scopes
1526      that we kept around.  */
1527   for (link = current_binding_level->dead_vars_from_for;
1528        link; link = TREE_CHAIN (link))
1529     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1530
1531   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1532   for (link = current_binding_level->type_shadowed;
1533        link; link = TREE_CHAIN (link))
1534     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1535
1536   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1537   for (link = current_binding_level->shadowed_labels;
1538        link;
1539        link = TREE_CHAIN (link))
1540     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1541
1542   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1543      list if a `using' declaration put them there.  The debugging
1544      back-ends won't understand OVERLOAD, so we remove them here.
1545      Because the BLOCK_VARS are (temporarily) shared with
1546      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1547      popped all the bindings.  */
1548   if (block)
1549     {
1550       tree* d;
1551
1552       for (d = &BLOCK_VARS (block); *d; )
1553         {
1554           if (TREE_CODE (*d) == TREE_LIST)
1555             *d = TREE_CHAIN (*d);
1556           else
1557             d = &TREE_CHAIN (*d);
1558         }
1559     }
1560
1561   /* If the level being exited is the top level of a function,
1562      check over all the labels.  */
1563   if (functionbody)
1564     {
1565       /* Since this is the top level block of a function, the vars are
1566          the function's parameters.  Don't leave them in the BLOCK
1567          because they are found in the FUNCTION_DECL instead.  */
1568       BLOCK_VARS (block) = 0;
1569       pop_labels (block);
1570     }
1571
1572   tmp = current_binding_level->keep;
1573
1574   pop_binding_level ();
1575   if (functionbody)
1576     DECL_INITIAL (current_function_decl) = block;
1577   else if (block)
1578     {
1579       if (!block_previously_created)
1580         current_binding_level->blocks
1581           = chainon (current_binding_level->blocks, block);
1582     }
1583   /* If we did not make a block for the level just exited,
1584      any blocks made for inner levels
1585      (since they cannot be recorded as subblocks in that level)
1586      must be carried forward so they will later become subblocks
1587      of something else.  */
1588   else if (subblocks)
1589     current_binding_level->blocks
1590       = chainon (current_binding_level->blocks, subblocks);
1591
1592   /* Each and every BLOCK node created here in `poplevel' is important
1593      (e.g. for proper debugging information) so if we created one
1594      earlier, mark it as "used".  */
1595   if (block)
1596     TREE_USED (block) = 1;
1597
1598   /* Take care of compiler's internal binding structures.  */
1599   if (tmp == 2)
1600     {
1601       tree scope_stmts;
1602
1603       scope_stmts
1604         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1605       if (block)
1606         {
1607           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1608           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1609         }
1610
1611       block = poplevel (keep, reverse, functionbody);
1612     }
1613
1614   return block;
1615 }
1616
1617 /* Delete the node BLOCK from the current binding level.
1618    This is used for the block inside a stmt expr ({...})
1619    so that the block can be reinserted where appropriate.  */
1620
1621 void
1622 delete_block (block)
1623      tree block;
1624 {
1625   tree t;
1626   if (current_binding_level->blocks == block)
1627     current_binding_level->blocks = TREE_CHAIN (block);
1628   for (t = current_binding_level->blocks; t;)
1629     {
1630       if (TREE_CHAIN (t) == block)
1631         TREE_CHAIN (t) = TREE_CHAIN (block);
1632       else
1633         t = TREE_CHAIN (t);
1634     }
1635   TREE_CHAIN (block) = NULL_TREE;
1636   /* Clear TREE_USED which is always set by poplevel.
1637      The flag is set again if insert_block is called.  */
1638   TREE_USED (block) = 0;
1639 }
1640
1641 /* Insert BLOCK at the end of the list of subblocks of the
1642    current binding level.  This is used when a BIND_EXPR is expanded,
1643    to handle the BLOCK node inside the BIND_EXPR.  */
1644
1645 void
1646 insert_block (block)
1647      tree block;
1648 {
1649   TREE_USED (block) = 1;
1650   current_binding_level->blocks
1651     = chainon (current_binding_level->blocks, block);
1652 }
1653
1654 /* Set the BLOCK node for the innermost scope
1655    (the one we are currently in).  */
1656
1657 void
1658 set_block (block)
1659     register tree block;
1660 {
1661   current_binding_level->this_block = block;
1662 }
1663
1664 /* Do a pushlevel for class declarations.  */
1665
1666 void
1667 pushlevel_class ()
1668 {
1669   register struct binding_level *newlevel;
1670
1671   /* Reuse or create a struct for this binding level.  */
1672 #if defined(DEBUG_CP_BINDING_LEVELS)
1673   if (0)
1674 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1675   if (free_binding_level)
1676 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1677     {
1678       newlevel = free_binding_level;
1679       free_binding_level = free_binding_level->level_chain;
1680     }
1681   else
1682     newlevel = make_binding_level ();
1683
1684 #if defined(DEBUG_CP_BINDING_LEVELS)
1685   is_class_level = 1;
1686 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1687
1688   push_binding_level (newlevel, 0, 0);
1689
1690   class_binding_level = current_binding_level;
1691   class_binding_level->parm_flag = 2;
1692   class_binding_level->this_class = current_class_type;
1693 }
1694
1695 /* ...and a poplevel for class declarations.  */
1696
1697 void
1698 poplevel_class ()
1699 {
1700   register struct binding_level *level = class_binding_level;
1701   tree shadowed;
1702
1703   my_friendly_assert (level != 0, 354);
1704
1705   /* If we're leaving a toplevel class, don't bother to do the setting
1706      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1707      shouldn't even be used when current_class_type isn't set, and second,
1708      if we don't touch it here, we're able to use the cache effect if the
1709      next time we're entering a class scope, it is the same class.  */
1710   if (current_class_depth != 1)
1711     {
1712       struct binding_level* b;
1713
1714       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1715       for (shadowed = level->class_shadowed;
1716            shadowed;
1717            shadowed = TREE_CHAIN (shadowed))
1718         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1719
1720       /* Find the next enclosing class, and recreate
1721          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1722       b = level->level_chain;
1723       while (b && b->parm_flag != 2)
1724         b = b->level_chain;
1725
1726       if (b)
1727         for (shadowed = b->class_shadowed;
1728              shadowed;
1729              shadowed = TREE_CHAIN (shadowed))
1730           {
1731             tree t;
1732
1733             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1734             while (t && BINDING_LEVEL (t) != b)
1735               t = TREE_CHAIN (t);
1736
1737             if (t)
1738               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1739                 = BINDING_VALUE (t);
1740           }
1741     }
1742   else
1743     /* Remember to save what IDENTIFIER's were bound in this scope so we
1744        can recover from cache misses.  */
1745     {
1746       previous_class_type = current_class_type;
1747       previous_class_values = class_binding_level->class_shadowed;
1748     }
1749   for (shadowed = level->type_shadowed;
1750        shadowed;
1751        shadowed = TREE_CHAIN (shadowed))
1752     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1753
1754   /* Remove the bindings for all of the class-level declarations.  */
1755   for (shadowed = level->class_shadowed;
1756        shadowed;
1757        shadowed = TREE_CHAIN (shadowed))
1758     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1759
1760   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1761                       (HOST_WIDE_INT) class_binding_level->level_chain,
1762                       class_binding_level->parm_flag,
1763                       class_binding_level->keep);
1764
1765   /* Now, pop out of the binding level which we created up in the
1766      `pushlevel_class' routine.  */
1767 #if defined(DEBUG_CP_BINDING_LEVELS)
1768   is_class_level = 1;
1769 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1770
1771   pop_binding_level ();
1772 }
1773
1774 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1775    for any names in enclosing classes.  */
1776
1777 void
1778 clear_identifier_class_values ()
1779 {
1780   tree t;
1781
1782   if (!class_binding_level)
1783     return;
1784
1785   for (t = class_binding_level->class_shadowed;
1786        t;
1787        t = TREE_CHAIN (t))
1788     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1789 }
1790
1791 /* Returns non-zero if T is a virtual function table.  */
1792
1793 int
1794 vtable_decl_p (t, data)
1795      tree t;
1796      void *data ATTRIBUTE_UNUSED;
1797 {
1798   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1799 }
1800
1801 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1802    functions.  */
1803
1804 int
1805 vtype_decl_p (t, data)
1806      tree t;
1807      void *data ATTRIBUTE_UNUSED;
1808 {
1809   return (TREE_CODE (t) == TYPE_DECL
1810           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1811           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1812 }
1813
1814 /* Return the declarations that are members of the namespace NS.  */
1815
1816 tree
1817 cp_namespace_decls (ns)
1818      tree ns;
1819 {
1820   return NAMESPACE_LEVEL (ns)->names;
1821 }
1822
1823 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1824    itself, calling F for each.  The DATA is passed to F as well.  */
1825
1826 static int
1827 walk_namespaces_r (namespace, f, data)
1828      tree namespace;
1829      walk_namespaces_fn f;
1830      void *data;
1831 {
1832   tree current;
1833   int result = 0;
1834
1835   result |= (*f) (namespace, data);
1836
1837   for (current = cp_namespace_decls (namespace);
1838        current;
1839        current = TREE_CHAIN (current))
1840     {
1841       if (TREE_CODE (current) != NAMESPACE_DECL
1842           || DECL_NAMESPACE_ALIAS (current))
1843         continue;
1844       if (!DECL_LANG_SPECIFIC (current))
1845         {
1846           /* Hmm. std. */
1847           my_friendly_assert (current == std_node, 393);
1848           continue;
1849         }
1850
1851       /* We found a namespace.  */
1852       result |= walk_namespaces_r (current, f, data);
1853     }
1854
1855   return result;
1856 }
1857
1858 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1859    F as well.  */
1860
1861 int
1862 walk_namespaces (f, data)
1863      walk_namespaces_fn f;
1864      void *data;
1865 {
1866   return walk_namespaces_r (global_namespace, f, data);
1867 }
1868
1869 struct walk_globals_data {
1870   walk_globals_pred p;
1871   walk_globals_fn f;
1872   void *data;
1873 };
1874
1875 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1876    for which P returns non-zero, call F with its address.  If any call
1877    to F returns a non-zero value, return a non-zero value.  */
1878
1879 static int
1880 walk_globals_r (namespace, data)
1881      tree namespace;
1882      void *data;
1883 {
1884   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1885   walk_globals_pred p = wgd->p;
1886   walk_globals_fn f = wgd->f;
1887   void *d = wgd->data;
1888   tree *t;
1889   int result = 0;
1890
1891   t = &NAMESPACE_LEVEL (namespace)->names;
1892
1893   while (*t)
1894     {
1895       tree glbl = *t;
1896
1897       if ((*p) (glbl, d))
1898         result |= (*f) (t, d);
1899
1900       /* If F changed *T, then *T still points at the next item to
1901          examine.  */
1902       if (*t == glbl)
1903         t = &TREE_CHAIN (*t);
1904     }
1905
1906   return result;
1907 }
1908
1909 /* Walk the global declarations.  Whenever one is found for which P
1910    returns non-zero, call F with its address.  If any call to F
1911    returns a non-zero value, return a non-zero value.  */
1912
1913 int
1914 walk_globals (p, f, data)
1915      walk_globals_pred p;
1916      walk_globals_fn f;
1917      void *data;
1918 {
1919   struct walk_globals_data wgd;
1920   wgd.p = p;
1921   wgd.f = f;
1922   wgd.data = data;
1923
1924   return walk_namespaces (walk_globals_r, &wgd);
1925 }
1926
1927 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1928    DATA is non-NULL, this is the last time we will call
1929    wrapup_global_declarations for this NAMESPACE.  */
1930
1931 int
1932 wrapup_globals_for_namespace (namespace, data)
1933      tree namespace;
1934      void *data;
1935 {
1936   tree globals = cp_namespace_decls (namespace);
1937   int len = list_length (globals);
1938   tree *vec = (tree *) alloca (sizeof (tree) * len);
1939   int i;
1940   int result;
1941   tree decl;
1942   int last_time = (data != 0);
1943
1944   if (last_time && namespace == global_namespace)
1945     /* Let compile_file handle the global namespace.  */
1946     return 0;
1947
1948   /* Process the decls in reverse order--earliest first.
1949      Put them into VEC from back to front, then take out from front.  */
1950
1951   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1952     {
1953       /* Pretend we've output an unused static variable.  This ensures
1954          that the toplevel __FUNCTION__ etc won't be emitted, unless
1955          needed. */
1956       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1957           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1958         {
1959           TREE_ASM_WRITTEN (decl) = 1;
1960           DECL_IGNORED_P (decl) = 1;
1961         }
1962       vec[len - i - 1] = decl;
1963     }
1964
1965   if (last_time)
1966     {
1967       check_global_declarations (vec, len);
1968       return 0;
1969     }
1970
1971   /* Temporarily mark vtables as external.  That prevents
1972      wrapup_global_declarations from writing them out; we must process
1973      them ourselves in finish_vtable_vardecl.  */
1974   for (i = 0; i < len; ++i)
1975     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1976       {
1977         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1978         DECL_EXTERNAL (vec[i]) = 1;
1979       }
1980
1981   /* Write out any globals that need to be output.  */
1982   result = wrapup_global_declarations (vec, len);
1983
1984   /* Undo the hack to DECL_EXTERNAL above.  */
1985   for (i = 0; i < len; ++i)
1986     if (vtable_decl_p (vec[i], /*data=*/0)
1987         && DECL_NOT_REALLY_EXTERN (vec[i]))
1988       {
1989         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1990         DECL_EXTERNAL (vec[i]) = 0;
1991       }
1992
1993   return result;
1994 }
1995
1996 \f
1997 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1998
1999 static void
2000 mark_binding_level (arg)
2001      void *arg;
2002 {
2003   struct binding_level *lvl = *(struct binding_level **)arg;
2004
2005   for (; lvl; lvl = lvl->level_chain)
2006     {
2007       ggc_mark_tree (lvl->names);
2008       ggc_mark_tree (lvl->tags);
2009       ggc_mark_tree (lvl->usings);
2010       ggc_mark_tree (lvl->using_directives);
2011       ggc_mark_tree (lvl->class_shadowed);
2012       ggc_mark_tree (lvl->type_shadowed);
2013       ggc_mark_tree (lvl->shadowed_labels);
2014       ggc_mark_tree (lvl->blocks);
2015       ggc_mark_tree (lvl->this_block);
2016       ggc_mark_tree (lvl->this_class);
2017       ggc_mark_tree (lvl->incomplete);
2018       ggc_mark_tree (lvl->dead_vars_from_for);
2019     }
2020 }
2021
2022 static void
2023 mark_named_label_lists (labs, uses)
2024      void *labs;
2025      void *uses;
2026 {
2027   struct named_label_list *l = *(struct named_label_list **)labs;
2028   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2029
2030   for (; l; l = l->next)
2031     {
2032       ggc_mark (l);
2033       mark_binding_level (l->binding_level);
2034       ggc_mark_tree (l->old_value);
2035       ggc_mark_tree (l->label_decl);
2036       ggc_mark_tree (l->bad_decls);
2037     }
2038
2039   for (; u; u = u->next)
2040     ggc_mark (u);
2041 }
2042 \f
2043 /* For debugging.  */
2044 static int no_print_functions = 0;
2045 static int no_print_builtins = 0;
2046
2047 void
2048 print_binding_level (lvl)
2049      struct binding_level *lvl;
2050 {
2051   tree t;
2052   int i = 0, len;
2053   fprintf (stderr, " blocks=");
2054   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2055   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2056            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2057   if (lvl->tag_transparent)
2058     fprintf (stderr, " tag-transparent");
2059   if (lvl->more_cleanups_ok)
2060     fprintf (stderr, " more-cleanups-ok");
2061   if (lvl->have_cleanups)
2062     fprintf (stderr, " have-cleanups");
2063   fprintf (stderr, "\n");
2064   if (lvl->names)
2065     {
2066       fprintf (stderr, " names:\t");
2067       /* We can probably fit 3 names to a line?  */
2068       for (t = lvl->names; t; t = TREE_CHAIN (t))
2069         {
2070           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2071             continue;
2072           if (no_print_builtins
2073               && (TREE_CODE (t) == TYPE_DECL)
2074               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2075             continue;
2076
2077           /* Function decls tend to have longer names.  */
2078           if (TREE_CODE (t) == FUNCTION_DECL)
2079             len = 3;
2080           else
2081             len = 2;
2082           i += len;
2083           if (i > 6)
2084             {
2085               fprintf (stderr, "\n\t");
2086               i = len;
2087             }
2088           print_node_brief (stderr, "", t, 0);
2089           if (t == error_mark_node)
2090             break;
2091         }
2092       if (i)
2093         fprintf (stderr, "\n");
2094     }
2095   if (lvl->tags)
2096     {
2097       fprintf (stderr, " tags:\t");
2098       i = 0;
2099       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2100         {
2101           if (TREE_PURPOSE (t) == NULL_TREE)
2102             len = 3;
2103           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2104             len = 2;
2105           else
2106             len = 4;
2107           i += len;
2108           if (i > 5)
2109             {
2110               fprintf (stderr, "\n\t");
2111               i = len;
2112             }
2113           if (TREE_PURPOSE (t) == NULL_TREE)
2114             {
2115               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2116               fprintf (stderr, ">");
2117             }
2118           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2119             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2120           else
2121             {
2122               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2123               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2124               fprintf (stderr, ">");
2125             }
2126         }
2127       if (i)
2128         fprintf (stderr, "\n");
2129     }
2130   if (lvl->class_shadowed)
2131     {
2132       fprintf (stderr, " class-shadowed:");
2133       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2134         {
2135           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2136         }
2137       fprintf (stderr, "\n");
2138     }
2139   if (lvl->type_shadowed)
2140     {
2141       fprintf (stderr, " type-shadowed:");
2142       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2143         {
2144           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2145         }
2146       fprintf (stderr, "\n");
2147     }
2148 }
2149
2150 void
2151 print_other_binding_stack (stack)
2152      struct binding_level *stack;
2153 {
2154   struct binding_level *level;
2155   for (level = stack; level != global_binding_level; level = level->level_chain)
2156     {
2157       fprintf (stderr, "binding level ");
2158       fprintf (stderr, HOST_PTR_PRINTF, level);
2159       fprintf (stderr, "\n");
2160       print_binding_level (level);
2161     }
2162 }
2163
2164 void
2165 print_binding_stack ()
2166 {
2167   struct binding_level *b;
2168   fprintf (stderr, "current_binding_level=");
2169   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2170   fprintf (stderr, "\nclass_binding_level=");
2171   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2172   fprintf (stderr, "\nglobal_binding_level=");
2173   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2174   fprintf (stderr, "\n");
2175   if (class_binding_level)
2176     {
2177       for (b = class_binding_level; b; b = b->level_chain)
2178         if (b == current_binding_level)
2179           break;
2180       if (b)
2181         b = class_binding_level;
2182       else
2183         b = current_binding_level;
2184     }
2185   else
2186     b = current_binding_level;
2187   print_other_binding_stack (b);
2188   fprintf (stderr, "global:\n");
2189   print_binding_level (global_binding_level);
2190 }
2191
2192 /* Namespace binding access routines: The namespace_bindings field of
2193    the identifier is polymorphic, with three possible values:
2194    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2195    indicating the BINDING_VALUE of global_namespace. */
2196
2197 /* Check whether the a binding for the name to scope is known.
2198    Assumes that the bindings of the name are already a list
2199    of bindings. Returns the binding found, or NULL_TREE. */
2200
2201 static tree
2202 find_binding (name, scope)
2203      tree name;
2204      tree scope;
2205 {
2206   tree iter, prev = NULL_TREE;
2207
2208   scope = ORIGINAL_NAMESPACE (scope);
2209
2210   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2211        iter = TREE_CHAIN (iter))
2212     {
2213       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2214       if (BINDING_SCOPE (iter) == scope)
2215         {
2216           /* Move binding found to the front of the list, so
2217              subsequent lookups will find it faster. */
2218           if (prev)
2219             {
2220               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2221               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2222               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2223             }
2224           return iter;
2225         }
2226       prev = iter;
2227     }
2228   return NULL_TREE;
2229 }
2230
2231 /* Always returns a binding for name in scope. If the
2232    namespace_bindings is not a list, convert it to one first.
2233    If no binding is found, make a new one. */
2234
2235 tree
2236 binding_for_name (name, scope)
2237      tree name;
2238      tree scope;
2239 {
2240   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2241   tree result;
2242
2243   scope = ORIGINAL_NAMESPACE (scope);
2244
2245   if (b && TREE_CODE (b) != CPLUS_BINDING)
2246     {
2247       /* Get rid of optimization for global scope. */
2248       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2249       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2250       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2251     }
2252   if (b && (result = find_binding (name, scope)))
2253     return result;
2254   /* Not found, make a new one. */
2255   result = make_node (CPLUS_BINDING);
2256   TREE_CHAIN (result) = b;
2257   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2258   BINDING_SCOPE (result) = scope;
2259   BINDING_TYPE (result) = NULL_TREE;
2260   BINDING_VALUE (result) = NULL_TREE;
2261   return result;
2262 }
2263
2264 /* Return the binding value for name in scope, considering that
2265    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2266
2267 tree
2268 namespace_binding (name, scope)
2269      tree name;
2270      tree scope;
2271 {
2272   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2273   if (b == NULL_TREE)
2274     return NULL_TREE;
2275   if (scope == NULL_TREE)
2276     scope = global_namespace;
2277   if (TREE_CODE (b) != CPLUS_BINDING)
2278     return (scope == global_namespace) ? b : NULL_TREE;
2279   name = find_binding (name,scope);
2280   if (name == NULL_TREE)
2281     return name;
2282   return BINDING_VALUE (name);
2283 }
2284
2285 /* Set the binding value for name in scope. If modifying the binding
2286    of global_namespace is attempted, try to optimize it. */
2287
2288 void
2289 set_namespace_binding (name, scope, val)
2290      tree name;
2291      tree scope;
2292      tree val;
2293 {
2294   tree b;
2295
2296   if (scope == NULL_TREE)
2297     scope = global_namespace;
2298
2299   if (scope == global_namespace)
2300     {
2301       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2302       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2303         {
2304           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2305           return;
2306         }
2307     }
2308   b = binding_for_name (name, scope);
2309   BINDING_VALUE (b) = val;
2310 }
2311
2312 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2313    select a name that is unique to this compilation unit.  */
2314
2315 void
2316 push_namespace (name)
2317      tree name;
2318 {
2319   tree d = NULL_TREE;
2320   int need_new = 1;
2321   int implicit_use = 0;
2322   int global = 0;
2323   if (!global_namespace)
2324     {
2325       /* This must be ::. */
2326       my_friendly_assert (name == get_identifier ("::"), 377);
2327       global = 1;
2328     }
2329   else if (!name)
2330     {
2331       /* The name of anonymous namespace is unique for the translation
2332          unit.  */
2333       if (!anonymous_namespace_name)
2334         anonymous_namespace_name = get_file_function_name ('N');
2335       name = anonymous_namespace_name;
2336       d = IDENTIFIER_NAMESPACE_VALUE (name);
2337       if (d)
2338         /* Reopening anonymous namespace.  */
2339         need_new = 0;
2340       implicit_use = 1;
2341     }
2342   else if (current_namespace == global_namespace
2343            && name == DECL_NAME (std_node))
2344     {
2345       in_std++;
2346       return;
2347     }
2348   else
2349     {
2350       /* Check whether this is an extended namespace definition. */
2351       d = IDENTIFIER_NAMESPACE_VALUE (name);
2352       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2353         {
2354           need_new = 0;
2355           if (DECL_NAMESPACE_ALIAS (d))
2356             {
2357               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2358                         d, DECL_NAMESPACE_ALIAS (d));
2359               d = DECL_NAMESPACE_ALIAS (d);
2360             }
2361         }
2362     }
2363
2364   if (need_new)
2365     {
2366       /* Make a new namespace, binding the name to it. */
2367       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2368       /* The global namespace is not pushed, and the global binding
2369          level is set elsewhere.  */
2370       if (!global)
2371         {
2372           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2373           d = pushdecl (d);
2374           pushlevel (0);
2375           declare_namespace_level ();
2376           NAMESPACE_LEVEL (d) = current_binding_level;
2377         }
2378     }
2379   else
2380     resume_binding_level (NAMESPACE_LEVEL (d));
2381
2382   if (implicit_use)
2383     do_using_directive (d);
2384   /* Enter the name space. */
2385   current_namespace = d;
2386 }
2387
2388 /* Pop from the scope of the current namespace.  */
2389
2390 void
2391 pop_namespace ()
2392 {
2393   if (current_namespace == global_namespace)
2394     {
2395       my_friendly_assert (in_std>0, 980421);
2396       in_std--;
2397       return;
2398     }
2399   current_namespace = CP_DECL_CONTEXT (current_namespace);
2400   /* The binding level is not popped, as it might be re-opened later.  */
2401   suspend_binding_level ();
2402 }
2403
2404 /* Push into the scope of the namespace NS, even if it is deeply
2405    nested within another namespace.  */
2406
2407 void
2408 push_nested_namespace (ns)
2409      tree ns;
2410 {
2411   if (ns == global_namespace)
2412     push_to_top_level ();
2413   else
2414     {
2415       push_nested_namespace (CP_DECL_CONTEXT (ns));
2416       push_namespace (DECL_NAME (ns));
2417     }
2418 }
2419
2420 /* Pop back from the scope of the namespace NS, which was previously
2421    entered with push_nested_namespace.  */
2422
2423 void
2424 pop_nested_namespace (ns)
2425      tree ns;
2426 {
2427   while (ns != global_namespace)
2428     {
2429       pop_namespace ();
2430       ns = CP_DECL_CONTEXT (ns);
2431     }
2432
2433   pop_from_top_level ();
2434 }
2435
2436 \f
2437 /* Subroutines for reverting temporarily to top-level for instantiation
2438    of templates and such.  We actually need to clear out the class- and
2439    local-value slots of all identifiers, so that only the global values
2440    are at all visible.  Simply setting current_binding_level to the global
2441    scope isn't enough, because more binding levels may be pushed.  */
2442 struct saved_scope *scope_chain;
2443
2444 /* Mark ST for GC.  */
2445
2446 static void
2447 mark_stmt_tree (st)
2448      struct stmt_tree *st;
2449 {
2450   ggc_mark_tree (st->x_last_stmt);
2451   ggc_mark_tree (st->x_last_expr_type);
2452 }
2453
2454 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2455
2456 static void
2457 mark_saved_scope (arg)
2458      void *arg;
2459 {
2460   struct saved_scope *t = *(struct saved_scope **)arg;
2461   while (t)
2462     {
2463       mark_binding_level (&t->class_bindings);
2464       ggc_mark_tree (t->old_bindings);
2465       ggc_mark_tree (t->old_namespace);
2466       ggc_mark_tree (t->class_name);
2467       ggc_mark_tree (t->class_type);
2468       ggc_mark_tree (t->access_specifier);
2469       ggc_mark_tree (t->function_decl);
2470       if (t->lang_base)
2471         ggc_mark_tree_varray (t->lang_base);
2472       ggc_mark_tree (t->lang_name);
2473       ggc_mark_tree (t->x_function_parms);
2474       ggc_mark_tree (t->template_parms);
2475       ggc_mark_tree (t->x_previous_class_type);
2476       ggc_mark_tree (t->x_previous_class_values);
2477       ggc_mark_tree (t->x_saved_tree);
2478       ggc_mark_tree (t->incomplete);
2479       ggc_mark_tree (t->lookups);
2480
2481       mark_stmt_tree (&t->x_stmt_tree);
2482       mark_binding_level (&t->bindings);
2483       t = t->prev;
2484     }
2485 }
2486
2487 static tree
2488 store_bindings (names, old_bindings)
2489      tree names, old_bindings;
2490 {
2491   tree t;
2492   for (t = names; t; t = TREE_CHAIN (t))
2493     {
2494       tree binding, t1, id;
2495
2496       if (TREE_CODE (t) == TREE_LIST)
2497         id = TREE_PURPOSE (t);
2498       else
2499         id = DECL_NAME (t);
2500
2501       if (!id
2502           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2503              we have no IDENTIFIER_BINDING if we have left the class
2504              scope, but cached the class-level declarations.  */
2505           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2506         continue;
2507
2508       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2509         if (TREE_VEC_ELT (t1, 0) == id)
2510           goto skip_it;
2511
2512       binding = make_tree_vec (4);
2513
2514       if (id)
2515         {
2516           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2517           TREE_VEC_ELT (binding, 0) = id;
2518           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2519           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2520           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2521           IDENTIFIER_BINDING (id) = NULL_TREE;
2522           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2523         }
2524       TREE_CHAIN (binding) = old_bindings;
2525       old_bindings = binding;
2526     skip_it:
2527       ;
2528     }
2529   return old_bindings;
2530 }
2531
2532 void
2533 maybe_push_to_top_level (pseudo)
2534      int pseudo;
2535 {
2536   struct saved_scope *s;
2537   struct binding_level *b;
2538   tree old_bindings;
2539   int need_pop;
2540
2541   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2542
2543   b = scope_chain ? current_binding_level : 0;
2544
2545   /* If we're in the middle of some function, save our state.  */
2546   if (cfun)
2547     {
2548       need_pop = 1;
2549       push_function_context_to (NULL_TREE);
2550     }
2551   else
2552     need_pop = 0;
2553
2554   old_bindings = NULL_TREE;
2555   if (scope_chain && previous_class_type)
2556     old_bindings = store_bindings (previous_class_values, old_bindings);
2557
2558   /* Have to include global_binding_level, because class-level decls
2559      aren't listed anywhere useful.  */
2560   for (; b; b = b->level_chain)
2561     {
2562       tree t;
2563
2564       /* Template IDs are inserted into the global level. If they were
2565          inserted into namespace level, finish_file wouldn't find them
2566          when doing pending instantiations. Therefore, don't stop at
2567          namespace level, but continue until :: .  */
2568       if (b == global_binding_level || (pseudo && b->template_parms_p))
2569         break;
2570
2571       old_bindings = store_bindings (b->names, old_bindings);
2572       /* We also need to check class_shadowed to save class-level type
2573          bindings, since pushclass doesn't fill in b->names.  */
2574       if (b->parm_flag == 2)
2575         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2576
2577       /* Unwind type-value slots back to top level.  */
2578       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2579         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2580     }
2581   s->prev = scope_chain;
2582   s->old_bindings = old_bindings;
2583   s->bindings = b;
2584   s->need_pop_function_context = need_pop;
2585   s->function_decl = current_function_decl;
2586
2587   scope_chain = s;
2588   current_function_decl = NULL_TREE;
2589   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2590   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2591   current_lang_name = lang_name_cplusplus;
2592   strict_prototype = strict_prototypes_lang_cplusplus;
2593   current_namespace = global_namespace;
2594 }
2595
2596 void
2597 push_to_top_level ()
2598 {
2599   maybe_push_to_top_level (0);
2600 }
2601
2602 void
2603 pop_from_top_level ()
2604 {
2605   struct saved_scope *s = scope_chain;
2606   tree t;
2607
2608   /* Clear out class-level bindings cache.  */
2609   if (previous_class_type)
2610     invalidate_class_lookup_cache ();
2611
2612   VARRAY_FREE (current_lang_base);
2613
2614   scope_chain = s->prev;
2615   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2616     {
2617       tree id = TREE_VEC_ELT (t, 0);
2618       if (id)
2619         {
2620           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2621           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2622           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2623         }
2624     }
2625
2626   if (current_lang_name == lang_name_cplusplus)
2627     strict_prototype = strict_prototypes_lang_cplusplus;
2628   else if (current_lang_name == lang_name_c)
2629     strict_prototype = strict_prototypes_lang_c;
2630
2631   /* If we were in the middle of compiling a function, restore our
2632      state.  */
2633   if (s->need_pop_function_context)
2634     pop_function_context_from (NULL_TREE);
2635   current_function_decl = s->function_decl;
2636
2637   free (s);
2638 }
2639 \f
2640 /* Push a definition of struct, union or enum tag "name".
2641    into binding_level "b".   "type" should be the type node,
2642    We assume that the tag "name" is not already defined.
2643
2644    Note that the definition may really be just a forward reference.
2645    In that case, the TYPE_SIZE will be a NULL_TREE.
2646
2647    C++ gratuitously puts all these tags in the name space.  */
2648
2649 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2650    record the shadowed value for this binding contour.  TYPE is
2651    the type that ID maps to.  */
2652
2653 static void
2654 set_identifier_type_value_with_scope (id, type, b)
2655      tree id;
2656      tree type;
2657      struct binding_level *b;
2658 {
2659   if (!b->namespace_p)
2660     {
2661       /* Shadow the marker, not the real thing, so that the marker
2662          gets restored later. */
2663       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2664       b->type_shadowed
2665         = tree_cons (id, old_type_value, b->type_shadowed);
2666     }
2667   else
2668     {
2669       tree binding = binding_for_name (id, current_namespace);
2670       BINDING_TYPE (binding) = type;
2671       /* Store marker instead of real type. */
2672       type = global_type_node;
2673     }
2674   SET_IDENTIFIER_TYPE_VALUE (id, type);
2675 }
2676
2677 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2678
2679 void
2680 set_identifier_type_value (id, type)
2681      tree id;
2682      tree type;
2683 {
2684   set_identifier_type_value_with_scope (id, type, current_binding_level);
2685 }
2686
2687 /* Return the type associated with id. */
2688
2689 tree
2690 identifier_type_value (id)
2691      tree id;
2692 {
2693   /* There is no type with that name, anywhere. */
2694   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2695     return NULL_TREE;
2696   /* This is not the type marker, but the real thing. */
2697   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2698     return REAL_IDENTIFIER_TYPE_VALUE (id);
2699   /* Have to search for it. It must be on the global level, now.
2700      Ask lookup_name not to return non-types. */
2701   id = lookup_name_real (id, 2, 1, 0);
2702   if (id)
2703     return TREE_TYPE (id);
2704   return NULL_TREE;
2705 }
2706
2707 /* Pop off extraneous binding levels left over due to syntax errors.
2708
2709    We don't pop past namespaces, as they might be valid.  */
2710
2711 void
2712 pop_everything ()
2713 {
2714 #ifdef DEBUG_CP_BINDING_LEVELS
2715   fprintf (stderr, "XXX entering pop_everything ()\n");
2716 #endif
2717   while (!toplevel_bindings_p ())
2718     {
2719       if (current_binding_level->parm_flag == 2)
2720         pop_nested_class ();
2721       else
2722         poplevel (0, 0, 0);
2723     }
2724 #ifdef DEBUG_CP_BINDING_LEVELS
2725   fprintf (stderr, "XXX leaving pop_everything ()\n");
2726 #endif
2727 }
2728
2729 /* The type TYPE is being declared.  If it is a class template, or a
2730    specialization of a class template, do any processing required and
2731    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2732    being declared a friend.  B is the binding level at which this TYPE
2733    should be bound.
2734
2735    Returns the TYPE_DECL for TYPE, which may have been altered by this
2736    processing.  */
2737
2738 static tree
2739 maybe_process_template_type_declaration (type, globalize, b)
2740      tree type;
2741      int globalize;
2742      struct binding_level* b;
2743 {
2744   tree decl = TYPE_NAME (type);
2745
2746   if (processing_template_parmlist)
2747     /* You can't declare a new template type in a template parameter
2748        list.  But, you can declare a non-template type:
2749
2750          template <class A*> struct S;
2751
2752        is a forward-declaration of `A'.  */
2753     ;
2754   else
2755     {
2756       maybe_check_template_type (type);
2757
2758       my_friendly_assert (IS_AGGR_TYPE (type)
2759                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2760
2761
2762       if (processing_template_decl)
2763         {
2764           /* This may change after the call to
2765              push_template_decl_real, but we want the original value.  */
2766           tree name = DECL_NAME (decl);
2767
2768           decl = push_template_decl_real (decl, globalize);
2769           /* If the current binding level is the binding level for the
2770              template parameters (see the comment in
2771              begin_template_parm_list) and the enclosing level is a class
2772              scope, and we're not looking at a friend, push the
2773              declaration of the member class into the class scope.  In the
2774              friend case, push_template_decl will already have put the
2775              friend into global scope, if appropriate.  */
2776           if (TREE_CODE (type) != ENUMERAL_TYPE
2777               && !globalize && b->template_parms_p
2778               && b->level_chain->parm_flag == 2)
2779             {
2780               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2781               /* Put this tag on the list of tags for the class, since
2782                  that won't happen below because B is not the class
2783                  binding level, but is instead the pseudo-global level.  */
2784               b->level_chain->tags =
2785                 tree_cons (name, type, b->level_chain->tags);
2786               if (!COMPLETE_TYPE_P (current_class_type))
2787                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2788             }
2789         }
2790     }
2791
2792   return decl;
2793 }
2794
2795 /* In C++, you don't have to write `struct S' to refer to `S'; you
2796    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2797    if the user had written `typedef struct S S'.  Create and return
2798    the TYPE_DECL for TYPE.  */
2799
2800 tree
2801 create_implicit_typedef (name, type)
2802      tree name;
2803      tree type;
2804 {
2805   tree decl;
2806
2807   decl = build_decl (TYPE_DECL, name, type);
2808   DECL_ARTIFICIAL (decl) = 1;
2809   /* There are other implicit type declarations, like the one *within*
2810      a class that allows you to write `S::S'.  We must distinguish
2811      amongst these.  */
2812   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2813   TYPE_NAME (type) = decl;
2814
2815   return decl;
2816 }
2817
2818 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2819    Normally put it into the inner-most non-tag-transparent scope,
2820    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2821    The latter is needed for implicit declarations.  */
2822
2823 void
2824 pushtag (name, type, globalize)
2825      tree name, type;
2826      int globalize;
2827 {
2828   register struct binding_level *b;
2829
2830   b = current_binding_level;
2831   while (b->tag_transparent
2832          || (globalize && b->parm_flag == 2))
2833     b = b->level_chain;
2834
2835   b->tags = tree_cons (name, type, b->tags);
2836
2837   if (name)
2838     {
2839       /* Do C++ gratuitous typedefing.  */
2840       if (IDENTIFIER_TYPE_VALUE (name) != type)
2841         {
2842           register tree d = NULL_TREE;
2843           int in_class = 0;
2844           tree context = TYPE_CONTEXT (type);
2845
2846           if (! context)
2847             {
2848               tree cs = current_scope ();
2849
2850               if (! globalize)
2851                 context = cs;
2852               else if (cs != NULL_TREE && TYPE_P (cs))
2853                 /* When declaring a friend class of a local class, we want
2854                    to inject the newly named class into the scope
2855                    containing the local class, not the namespace scope.  */
2856                 context = decl_function_context (get_type_decl (cs));
2857             }
2858           if (!context)
2859             context = current_namespace;
2860
2861           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2862               || b->parm_flag == 2)
2863             in_class = 1;
2864
2865           if (current_lang_name == lang_name_java)
2866             TYPE_FOR_JAVA (type) = 1;
2867
2868           d = create_implicit_typedef (name, type);
2869           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2870           if (! in_class)
2871             set_identifier_type_value_with_scope (name, type, b);
2872
2873           d = maybe_process_template_type_declaration (type,
2874                                                        globalize, b);
2875
2876           if (b->parm_flag == 2)
2877             {
2878               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2879                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2880                    class.  But if it's a member template class, we
2881                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2882                    is done later.  */
2883                 finish_member_declaration (d);
2884               else
2885                 pushdecl_class_level (d);
2886             }
2887           else
2888             d = pushdecl_with_scope (d, b);
2889
2890           if (ANON_AGGRNAME_P (name))
2891             DECL_IGNORED_P (d) = 1;
2892
2893           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2894           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2895
2896           /* If this is a local class, keep track of it.  We need this
2897              information for name-mangling, and so that it is possible to find
2898              all function definitions in a translation unit in a convenient
2899              way.  (It's otherwise tricky to find a member function definition
2900              it's only pointed to from within a local class.)  */
2901           if (TYPE_CONTEXT (type)
2902               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2903               && !processing_template_decl)
2904             VARRAY_PUSH_TREE (local_classes, type);
2905
2906           if (!uses_template_parms (type))
2907             {
2908               if (flag_new_abi)
2909                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2910               else
2911                 DECL_ASSEMBLER_NAME (d)
2912                   = get_identifier (build_overload_name (type, 1, 1));
2913             }
2914         }
2915       if (b->parm_flag == 2)
2916         {
2917           if (!COMPLETE_TYPE_P (current_class_type))
2918             CLASSTYPE_TAGS (current_class_type) = b->tags;
2919         }
2920     }
2921
2922   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2923     /* Use the canonical TYPE_DECL for this node.  */
2924     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2925   else
2926     {
2927       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2928          will be the tagged type we just added to the current
2929          binding level.  This fake NULL-named TYPE_DECL node helps
2930          dwarfout.c to know when it needs to output a
2931          representation of a tagged type, and it also gives us a
2932          convenient place to record the "scope start" address for
2933          the tagged type.  */
2934
2935       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2936       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2937     }
2938 }
2939
2940 /* Counter used to create anonymous type names.  */
2941
2942 static int anon_cnt = 0;
2943
2944 /* Return an IDENTIFIER which can be used as a name for
2945    anonymous structs and unions.  */
2946
2947 tree
2948 make_anon_name ()
2949 {
2950   char buf[32];
2951
2952   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2953   return get_identifier (buf);
2954 }
2955
2956 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2957    This keeps dbxout from getting confused.  */
2958
2959 void
2960 clear_anon_tags ()
2961 {
2962   register struct binding_level *b;
2963   register tree tags;
2964   static int last_cnt = 0;
2965
2966   /* Fast out if no new anon names were declared.  */
2967   if (last_cnt == anon_cnt)
2968     return;
2969
2970   b = current_binding_level;
2971   while (b->tag_transparent)
2972     b = b->level_chain;
2973   tags = b->tags;
2974   while (tags)
2975     {
2976       /* A NULL purpose means we have already processed all tags
2977          from here to the end of the list.  */
2978       if (TREE_PURPOSE (tags) == NULL_TREE)
2979         break;
2980       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2981         TREE_PURPOSE (tags) = NULL_TREE;
2982       tags = TREE_CHAIN (tags);
2983     }
2984   last_cnt = anon_cnt;
2985 }
2986 \f
2987 /* Subroutine of duplicate_decls: return truthvalue of whether
2988    or not types of these decls match.
2989
2990    For C++, we must compare the parameter list so that `int' can match
2991    `int&' in a parameter position, but `int&' is not confused with
2992    `const int&'.  */
2993
2994 int
2995 decls_match (newdecl, olddecl)
2996      tree newdecl, olddecl;
2997 {
2998   int types_match;
2999
3000   if (newdecl == olddecl)
3001     return 1;
3002
3003   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
3004     /* If the two DECLs are not even the same kind of thing, we're not
3005        interested in their types.  */
3006     return 0;
3007
3008   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3009     {
3010       tree f1 = TREE_TYPE (newdecl);
3011       tree f2 = TREE_TYPE (olddecl);
3012       tree p1 = TYPE_ARG_TYPES (f1);
3013       tree p2 = TYPE_ARG_TYPES (f2);
3014
3015       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3016           && ! (DECL_EXTERN_C_P (newdecl)
3017                 && DECL_EXTERN_C_P (olddecl)))
3018         return 0;
3019
3020       if (TREE_CODE (f1) != TREE_CODE (f2))
3021         return 0;
3022
3023       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3024         {
3025           if ((! strict_prototypes_lang_c || DECL_BUILT_IN (olddecl))
3026               && DECL_EXTERN_C_P (olddecl)
3027               && p2 == NULL_TREE)
3028             {
3029               types_match = self_promoting_args_p (p1);
3030               if (p1 == void_list_node)
3031                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3032             }
3033           else if (!strict_prototypes_lang_c
3034                    && DECL_EXTERN_C_P (olddecl)
3035                    && DECL_EXTERN_C_P (newdecl)
3036                    && p1 == NULL_TREE)
3037             {
3038               types_match = self_promoting_args_p (p2);
3039               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3040             }
3041           else
3042             types_match = compparms (p1, p2);
3043         }
3044       else
3045         types_match = 0;
3046     }
3047   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3048     {
3049       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3050                                 DECL_TEMPLATE_PARMS (olddecl)))
3051         return 0;
3052
3053       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3054           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3055         return 0;
3056
3057       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3058         types_match = 1;
3059       else
3060         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3061                                    DECL_TEMPLATE_RESULT (newdecl));
3062     }
3063   else
3064     {
3065       if (TREE_TYPE (newdecl) == error_mark_node)
3066         types_match = TREE_TYPE (olddecl) == error_mark_node;
3067       else if (TREE_TYPE (olddecl) == NULL_TREE)
3068         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3069       else if (TREE_TYPE (newdecl) == NULL_TREE)
3070         types_match = 0;
3071       else
3072         types_match = comptypes (TREE_TYPE (newdecl),
3073                                  TREE_TYPE (olddecl),
3074                                  COMPARE_REDECLARATION);
3075     }
3076
3077   return types_match;
3078 }
3079
3080 /* If NEWDECL is `static' and an `extern' was seen previously,
3081    warn about it.  OLDDECL is the previous declaration.
3082
3083    Note that this does not apply to the C++ case of declaring
3084    a variable `extern const' and then later `const'.
3085
3086    Don't complain about built-in functions, since they are beyond
3087    the user's control.  */
3088
3089 static void
3090 warn_extern_redeclared_static (newdecl, olddecl)
3091      tree newdecl, olddecl;
3092 {
3093   static const char *explicit_extern_static_warning
3094     = "`%D' was declared `extern' and later `static'";
3095   static const char *implicit_extern_static_warning
3096     = "`%D' was declared implicitly `extern' and later `static'";
3097
3098   tree name;
3099
3100   if (TREE_CODE (newdecl) == TYPE_DECL
3101       || TREE_CODE (newdecl) == TEMPLATE_DECL
3102       || TREE_CODE (newdecl) == CONST_DECL)
3103     return;
3104
3105   /* Don't get confused by static member functions; that's a different
3106      use of `static'.  */
3107   if (TREE_CODE (newdecl) == FUNCTION_DECL
3108       && DECL_STATIC_FUNCTION_P (newdecl))
3109     return;
3110
3111   /* If the old declaration was `static', or the new one isn't, then
3112      then everything is OK.  */
3113   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3114     return;
3115
3116   /* It's OK to declare a builtin function as `static'.  */
3117   if (TREE_CODE (olddecl) == FUNCTION_DECL
3118       && DECL_ARTIFICIAL (olddecl))
3119     return;
3120
3121   name = DECL_ASSEMBLER_NAME (newdecl);
3122   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3123               ? implicit_extern_static_warning
3124               : explicit_extern_static_warning, newdecl);
3125   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3126 }
3127
3128 /* Handle when a new declaration NEWDECL has the same name as an old
3129    one OLDDECL in the same binding contour.  Prints an error message
3130    if appropriate.
3131
3132    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3133    Otherwise, return 0.  */
3134
3135 int
3136 duplicate_decls (newdecl, olddecl)
3137      tree newdecl, olddecl;
3138 {
3139   unsigned olddecl_uid = DECL_UID (olddecl);
3140   int olddecl_friend = 0, types_match = 0;
3141   int new_defines_function = 0;
3142
3143   if (newdecl == olddecl)
3144     return 1;
3145
3146   types_match = decls_match (newdecl, olddecl);
3147
3148   /* If either the type of the new decl or the type of the old decl is an
3149      error_mark_node, then that implies that we have already issued an
3150      error (earlier) for some bogus type specification, and in that case,
3151      it is rather pointless to harass the user with yet more error message
3152      about the same declaration, so just pretend the types match here.  */
3153   if (TREE_TYPE (newdecl) == error_mark_node
3154       || TREE_TYPE (olddecl) == error_mark_node)
3155     types_match = 1;
3156
3157   /* Check for redeclaration and other discrepancies. */
3158   if (TREE_CODE (olddecl) == FUNCTION_DECL
3159       && DECL_ARTIFICIAL (olddecl))
3160     {
3161       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3162         {
3163           /* If you declare a built-in or predefined function name as static,
3164              the old definition is overridden, but optionally warn this was a
3165              bad choice of name.  */
3166           if (! TREE_PUBLIC (newdecl))
3167             {
3168               if (warn_shadow)
3169                 cp_warning ("shadowing %s function `%#D'",
3170                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3171                             olddecl);
3172               /* Discard the old built-in function.  */
3173               return 0;
3174             }
3175           /* If the built-in is not ansi, then programs can override
3176              it even globally without an error.  */
3177           else if (! DECL_BUILT_IN (olddecl))
3178             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3179                         olddecl, newdecl);
3180           else
3181             {
3182               cp_error ("declaration of `%#D'", newdecl);
3183               cp_error ("conflicts with built-in declaration `%#D'",
3184                         olddecl);
3185             }
3186           return 0;
3187         }
3188       else if (!types_match)
3189         {
3190           if ((DECL_EXTERN_C_P (newdecl)
3191                && DECL_EXTERN_C_P (olddecl))
3192               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3193                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3194             {
3195               /* A near match; override the builtin.  */
3196
3197               if (TREE_PUBLIC (newdecl))
3198                 {
3199                   cp_warning ("new declaration `%#D'", newdecl);
3200                   cp_warning ("ambiguates built-in declaration `%#D'",
3201                               olddecl);
3202                 }
3203               else if (warn_shadow)
3204                 cp_warning ("shadowing %s function `%#D'",
3205                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3206                             olddecl);
3207             }
3208           else
3209             /* Discard the old built-in function.  */
3210             return 0;
3211         }
3212
3213       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3214         {
3215           /* If a builtin function is redeclared as `static', merge
3216              the declarations, but make the original one static.  */
3217           DECL_THIS_STATIC (olddecl) = 1;
3218           TREE_PUBLIC (olddecl) = 0;
3219
3220           /* Make the old declaration consistent with the new one so
3221              that all remnants of the builtin-ness of this function
3222              will be banished.  */
3223           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3224           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3225           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3226           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3227                                        newdecl);
3228         }
3229     }
3230   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3231     {
3232       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3233            && TREE_CODE (newdecl) != TYPE_DECL
3234            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3235                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3236           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3237               && TREE_CODE (olddecl) != TYPE_DECL
3238               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3239                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3240                         == TYPE_DECL))))
3241         {
3242           /* We do nothing special here, because C++ does such nasty
3243              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3244              get shadowed, and know that if we need to find a TYPE_DECL
3245              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3246              slot of the identifier.  */
3247           return 0;
3248         }
3249
3250       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3251            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3252           || (TREE_CODE (olddecl) == FUNCTION_DECL
3253               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3254         return 0;
3255
3256       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3257       if (TREE_CODE (olddecl) == TREE_LIST)
3258         olddecl = TREE_VALUE (olddecl);
3259       cp_error_at ("previous declaration of `%#D'", olddecl);
3260
3261       /* New decl is completely inconsistent with the old one =>
3262          tell caller to replace the old one.  */
3263
3264       return 0;
3265     }
3266   else if (!types_match)
3267     {
3268       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3269         /* These are certainly not duplicate declarations; they're
3270            from different scopes.  */
3271         return 0;
3272
3273       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3274         {
3275           /* The name of a class template may not be declared to refer to
3276              any other template, class, function, object, namespace, value,
3277              or type in the same scope.  */
3278           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3279               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3280             {
3281               cp_error ("declaration of template `%#D'", newdecl);
3282               cp_error_at ("conflicts with previous declaration `%#D'",
3283                            olddecl);
3284             }
3285           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3286                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3287                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3288                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3289                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3290                                            DECL_TEMPLATE_PARMS (olddecl)))
3291             {
3292               cp_error ("new declaration `%#D'", newdecl);
3293               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3294             }
3295           return 0;
3296         }
3297       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3298         {
3299           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3300             {
3301               cp_error ("declaration of C function `%#D' conflicts with",
3302                         newdecl);
3303               cp_error_at ("previous declaration `%#D' here", olddecl);
3304             }
3305           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3306                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3307             {
3308               cp_error ("new declaration `%#D'", newdecl);
3309               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3310             }
3311           else
3312             return 0;
3313         }
3314
3315       /* Already complained about this, so don't do so again.  */
3316       else if (current_class_type == NULL_TREE
3317           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3318         {
3319           cp_error ("conflicting types for `%#D'", newdecl);
3320           cp_error_at ("previous declaration as `%#D'", olddecl);
3321         }
3322     }
3323   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3324             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3325                  && (!DECL_TEMPLATE_INFO (newdecl)
3326                      || (DECL_TI_TEMPLATE (newdecl)
3327                          != DECL_TI_TEMPLATE (olddecl))))
3328                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3329                     && (!DECL_TEMPLATE_INFO (olddecl)
3330                         || (DECL_TI_TEMPLATE (olddecl)
3331                             != DECL_TI_TEMPLATE (newdecl))))))
3332     /* It's OK to have a template specialization and a non-template
3333        with the same type, or to have specializations of two
3334        different templates with the same type.  Note that if one is a
3335        specialization, and the other is an instantiation of the same
3336        template, that we do not exit at this point.  That situation
3337        can occur if we instantiate a template class, and then
3338        specialize one of its methods.  This situation is legal, but
3339        the declarations must be merged in the usual way.  */
3340     return 0;
3341   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3342            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3343                 && !DECL_USE_TEMPLATE (newdecl))
3344                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3345                    && !DECL_USE_TEMPLATE (olddecl))))
3346     /* One of the declarations is a template instantiation, and the
3347        other is not a template at all.  That's OK.  */
3348     return 0;
3349   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3350            && DECL_NAMESPACE_ALIAS (newdecl)
3351            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3352     /* Redeclaration of namespace alias, ignore it. */
3353     return 1;
3354   else
3355     {
3356       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3357       if (errmsg)
3358         {
3359           cp_error (errmsg, newdecl);
3360           if (DECL_NAME (olddecl) != NULL_TREE)
3361             cp_error_at ((DECL_INITIAL (olddecl)
3362                           && namespace_bindings_p ())
3363                          ? "`%#D' previously defined here"
3364                          : "`%#D' previously declared here", olddecl);
3365         }
3366       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3367                && DECL_INITIAL (olddecl) != NULL_TREE
3368                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3369                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3370         {
3371           /* Prototype decl follows defn w/o prototype.  */
3372           cp_warning_at ("prototype for `%#D'", newdecl);
3373           cp_warning_at ("follows non-prototype definition here", olddecl);
3374         }
3375       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3376                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3377         {
3378           /* extern "C" int foo ();
3379              int foo () { bar (); }
3380              is OK.  */
3381           if (current_lang_stack
3382               == &VARRAY_TREE (current_lang_base, 0))
3383             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3384           else
3385             {
3386               cp_error_at ("previous declaration of `%#D' with %L linkage",
3387                            olddecl, DECL_LANGUAGE (olddecl));
3388               cp_error ("conflicts with new declaration with %L linkage",
3389                         DECL_LANGUAGE (newdecl));
3390             }
3391         }
3392
3393       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3394         ;
3395       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3396         {
3397           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3398           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3399           int i = 1;
3400
3401           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3402             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3403
3404           for (; t1 && t1 != void_list_node;
3405                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3406             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3407               {
3408                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3409                                            TREE_PURPOSE (t2)))
3410                   {
3411                     if (pedantic)
3412                       {
3413                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3414                                     i, newdecl);
3415                         cp_pedwarn_at ("after previous specification in `%#D'",
3416                                        olddecl);
3417                       }
3418                   }
3419                 else
3420                   {
3421                     cp_error ("default argument given for parameter %d of `%#D'",
3422                               i, newdecl);
3423                     cp_error_at ("after previous specification in `%#D'",
3424                                  olddecl);
3425                   }
3426               }
3427
3428           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3429               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3430             {
3431               cp_warning ("`%#D' was used before it was declared inline",
3432                           newdecl);
3433               cp_warning_at ("previous non-inline declaration here",
3434                              olddecl);
3435             }
3436         }
3437     }
3438
3439   /* If new decl is `static' and an `extern' was seen previously,
3440      warn about it.  */
3441   warn_extern_redeclared_static (newdecl, olddecl);
3442
3443   /* We have committed to returning 1 at this point.  */
3444   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3445     {
3446       /* Now that functions must hold information normally held
3447          by field decls, there is extra work to do so that
3448          declaration information does not get destroyed during
3449          definition.  */
3450       if (DECL_VINDEX (olddecl))
3451         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3452       if (DECL_VIRTUAL_CONTEXT (olddecl))
3453         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3454       if (DECL_CONTEXT (olddecl))
3455         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3456       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3457         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3458       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3459       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3460       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3461       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3462       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3463       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3464       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3465       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3466
3467       /* Optionally warn about more than one declaration for the same
3468          name, but don't warn about a function declaration followed by a
3469          definition.  */
3470       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3471           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3472           /* Don't warn about extern decl followed by definition. */
3473           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3474           /* Don't warn about friends, let add_friend take care of it. */
3475           && ! DECL_FRIEND_P (newdecl))
3476         {
3477           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3478           cp_warning_at ("previous declaration of `%D'", olddecl);
3479         }
3480     }
3481
3482   /* Deal with C++: must preserve virtual function table size.  */
3483   if (TREE_CODE (olddecl) == TYPE_DECL)
3484     {
3485       register tree newtype = TREE_TYPE (newdecl);
3486       register tree oldtype = TREE_TYPE (olddecl);
3487
3488       if (newtype != error_mark_node && oldtype != error_mark_node
3489           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3490         {
3491           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3492           CLASSTYPE_FRIEND_CLASSES (newtype)
3493             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3494         }
3495
3496       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3497     }
3498
3499   /* Copy all the DECL_... slots specified in the new decl
3500      except for any that we copy here from the old type.  */
3501   DECL_MACHINE_ATTRIBUTES (newdecl)
3502     = merge_machine_decl_attributes (olddecl, newdecl);
3503
3504   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3505     {
3506       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3507       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3508         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3509                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3510
3511       return 1;
3512     }
3513
3514   if (types_match)
3515     {
3516       /* Automatically handles default parameters.  */
3517       tree oldtype = TREE_TYPE (olddecl);
3518       tree newtype;
3519
3520       /* Merge the data types specified in the two decls.  */
3521       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3522
3523       if (TREE_CODE (newdecl) == VAR_DECL)
3524         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3525       /* Do this after calling `common_type' so that default
3526          parameters don't confuse us.  */
3527       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3528           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3529               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3530         {
3531           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3532                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3533           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3534                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3535
3536           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3537               && DECL_SOURCE_LINE (olddecl) != 0
3538               && flag_exceptions
3539               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3540                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3541             {
3542               cp_error ("declaration of `%F' throws different exceptions",
3543                         newdecl);
3544               cp_error_at ("than previous declaration `%F'", olddecl);
3545             }
3546         }
3547       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3548
3549       /* Lay the type out, unless already done.  */
3550       if (! same_type_p (newtype, oldtype)
3551           && TREE_TYPE (newdecl) != error_mark_node
3552           && !(processing_template_decl && uses_template_parms (newdecl)))
3553         layout_type (TREE_TYPE (newdecl));
3554
3555       if ((TREE_CODE (newdecl) == VAR_DECL
3556            || TREE_CODE (newdecl) == PARM_DECL
3557            || TREE_CODE (newdecl) == RESULT_DECL
3558            || TREE_CODE (newdecl) == FIELD_DECL
3559            || TREE_CODE (newdecl) == TYPE_DECL)
3560           && !(processing_template_decl && uses_template_parms (newdecl)))
3561         layout_decl (newdecl, 0);
3562
3563       /* Merge the type qualifiers.  */
3564       if (TREE_READONLY (newdecl))
3565         TREE_READONLY (olddecl) = 1;
3566       if (TREE_THIS_VOLATILE (newdecl))
3567         TREE_THIS_VOLATILE (olddecl) = 1;
3568
3569       /* Merge the initialization information.  */
3570       if (DECL_INITIAL (newdecl) == NULL_TREE
3571           && DECL_INITIAL (olddecl) != NULL_TREE)
3572         {
3573           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3574           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3575           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3576           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3577               && DECL_LANG_SPECIFIC (newdecl)
3578               && DECL_LANG_SPECIFIC (olddecl))
3579             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3580         }
3581
3582       /* Merge the section attribute.
3583          We want to issue an error if the sections conflict but that must be
3584          done later in decl_attributes since we are called before attributes
3585          are assigned.  */
3586       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3587         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3588
3589       /* Keep the old rtl since we can safely use it.  */
3590       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3591
3592       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3593         {
3594           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3595             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3596           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3597             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3598           DECL_NO_LIMIT_STACK (newdecl)
3599             |= DECL_NO_LIMIT_STACK (olddecl);
3600         }
3601     }
3602   /* If cannot merge, then use the new type and qualifiers,
3603      and don't preserve the old rtl.  */
3604   else
3605     {
3606       /* Clean out any memory we had of the old declaration.  */
3607       tree oldstatic = value_member (olddecl, static_aggregates);
3608       if (oldstatic)
3609         TREE_VALUE (oldstatic) = error_mark_node;
3610
3611       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3612       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3613       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3614       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3615     }
3616
3617   /* Merge the storage class information.  */
3618   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3619   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3620   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3621   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3622   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3623   if (! DECL_EXTERNAL (olddecl))
3624     DECL_EXTERNAL (newdecl) = 0;
3625
3626   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3627     {
3628       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3629       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3630       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3631       DECL_TEMPLATE_INSTANTIATED (newdecl)
3632         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3633       /* Don't really know how much of the language-specific
3634          values we should copy from old to new.  */
3635       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3636       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3637       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3638       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3639       olddecl_friend = DECL_FRIEND_P (olddecl);
3640
3641       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3642       if (TREE_CODE (newdecl) == FUNCTION_DECL
3643           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3644         DECL_BEFRIENDING_CLASSES (newdecl)
3645           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3646                      DECL_BEFRIENDING_CLASSES (olddecl));
3647     }
3648
3649   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3650     {
3651       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3652           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3653         {
3654           /* If newdecl is not a specialization, then it is not a
3655              template-related function at all.  And that means that we
3656              shoud have exited above, returning 0.  */
3657           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3658                               0);
3659
3660           if (TREE_USED (olddecl))
3661             /* From [temp.expl.spec]:
3662
3663                If a template, a member template or the member of a class
3664                template is explicitly specialized then that
3665                specialization shall be declared before the first use of
3666                that specialization that would cause an implicit
3667                instantiation to take place, in every translation unit in
3668                which such a use occurs.  */
3669             cp_error ("explicit specialization of %D after first use",
3670                       olddecl);
3671
3672           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3673         }
3674       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3675
3676       /* If either decl says `inline', this fn is inline, unless its
3677          definition was passed already.  */
3678       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3679         DECL_INLINE (olddecl) = 1;
3680       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3681
3682       if (! types_match)
3683         {
3684           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3685           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3686           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3687         }
3688       if (! types_match || new_defines_function)
3689         {
3690           /* These need to be copied so that the names are available.
3691              Note that if the types do match, we'll preserve inline
3692              info and other bits, but if not, we won't.  */
3693           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3694           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3695         }
3696       if (new_defines_function)
3697         /* If defining a function declared with other language
3698            linkage, use the previously declared language linkage.  */
3699         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3700       else if (types_match)
3701         {
3702           /* If redeclaring a builtin function, and not a definition,
3703              it stays built in.  */
3704           if (DECL_BUILT_IN (olddecl))
3705             {
3706               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3707               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3708               /* If we're keeping the built-in definition, keep the rtl,
3709                  regardless of declaration matches.  */
3710               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3711             }
3712           else
3713             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3714
3715           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3716           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3717             /* Previously saved insns go together with
3718                the function's previous definition.  */
3719             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3720           /* Don't clear out the arguments if we're redefining a function.  */
3721           if (DECL_ARGUMENTS (olddecl))
3722             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3723         }
3724     }
3725
3726   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3727     {
3728       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3729     }
3730
3731   /* Now preserve various other info from the definition.  */
3732   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3733   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3734   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3735   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3736
3737   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3738     {
3739       int function_size;
3740
3741       function_size = sizeof (struct tree_decl);
3742
3743       bcopy ((char *) newdecl + sizeof (struct tree_common),
3744              (char *) olddecl + sizeof (struct tree_common),
3745              function_size - sizeof (struct tree_common));
3746
3747       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3748         {
3749           /* If newdecl is a template instantiation, it is possible that
3750              the following sequence of events has occurred:
3751
3752              o A friend function was declared in a class template.  The
3753              class template was instantiated.
3754
3755              o The instantiation of the friend declaration was
3756              recorded on the instantiation list, and is newdecl.
3757
3758              o Later, however, instantiate_class_template called pushdecl
3759              on the newdecl to perform name injection.  But, pushdecl in
3760              turn called duplicate_decls when it discovered that another
3761              declaration of a global function with the same name already
3762              existed.
3763
3764              o Here, in duplicate_decls, we decided to clobber newdecl.
3765
3766              If we're going to do that, we'd better make sure that
3767              olddecl, and not newdecl, is on the list of
3768              instantiations so that if we try to do the instantiation
3769              again we won't get the clobbered declaration.  */
3770
3771           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3772           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3773
3774           for (; decls; decls = TREE_CHAIN (decls))
3775             if (TREE_VALUE (decls) == newdecl)
3776               TREE_VALUE (decls) = olddecl;
3777         }
3778     }
3779   else
3780     {
3781       bcopy ((char *) newdecl + sizeof (struct tree_common),
3782              (char *) olddecl + sizeof (struct tree_common),
3783              sizeof (struct tree_decl) - sizeof (struct tree_common)
3784              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3785     }
3786
3787   DECL_UID (olddecl) = olddecl_uid;
3788   if (olddecl_friend)
3789     DECL_FRIEND_P (olddecl) = 1;
3790
3791   /* NEWDECL contains the merged attribute lists.
3792      Update OLDDECL to be the same.  */
3793   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3794
3795   return 1;
3796 }
3797
3798 /* Record a decl-node X as belonging to the current lexical scope.
3799    Check for errors (such as an incompatible declaration for the same
3800    name already seen in the same scope).
3801
3802    Returns either X or an old decl for the same name.
3803    If an old decl is returned, it may have been smashed
3804    to agree with what X says.  */
3805
3806 tree
3807 pushdecl (x)
3808      tree x;
3809 {
3810   register tree t;
3811   register tree name;
3812   int need_new_binding;
3813
3814   /* We shouldn't be calling pushdecl when we're generating RTL for a
3815      function that we already did semantic analysis on previously.  */
3816   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3817                       19990913);
3818
3819   need_new_binding = 1;
3820
3821   if (DECL_TEMPLATE_PARM_P (x))
3822     /* Template parameters have no context; they are not X::T even
3823        when declared within a class or namespace.  */
3824     ;
3825   else
3826     {
3827       if (current_function_decl && x != current_function_decl
3828           /* A local declaration for a function doesn't constitute
3829              nesting.  */
3830           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3831           /* A local declaration for an `extern' variable is in the
3832              scoped of the current namespace, not the current
3833              function.  */
3834           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3835           && !DECL_CONTEXT (x))
3836         DECL_CONTEXT (x) = current_function_decl;
3837
3838       /* If this is the declaration for a namespace-scope function,
3839          but the declaration itself is in a local scope, mark the
3840          declaration.  */
3841       if (TREE_CODE (x) == FUNCTION_DECL
3842           && DECL_NAMESPACE_SCOPE_P (x)
3843           && current_function_decl
3844           && x != current_function_decl)
3845         DECL_LOCAL_FUNCTION_P (x) = 1;
3846     }
3847
3848   name = DECL_NAME (x);
3849   if (name)
3850     {
3851 #if 0
3852       /* Not needed...see below.  */
3853       char *file;
3854       int line;
3855 #endif
3856       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3857         name = TREE_OPERAND (name, 0);
3858
3859       /* Namespace-scoped variables are not found in the current level. */
3860       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3861         t = namespace_binding (name, DECL_CONTEXT (x));
3862       else
3863         t = lookup_name_current_level (name);
3864
3865       /* If we are declaring a function, and the result of name-lookup
3866          was an OVERLOAD, look for an overloaded instance that is
3867          actually the same as the function we are declaring.  (If
3868          there is one, we have to merge our declaration with the
3869          previous declaration.)  */
3870       if (t && TREE_CODE (t) == OVERLOAD)
3871         {
3872           tree match;
3873
3874           if (TREE_CODE (x) == FUNCTION_DECL)
3875             for (match = t; match; match = OVL_NEXT (match))
3876               {
3877                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3878                     == DECL_ASSEMBLER_NAME (x))
3879                   break;
3880               }
3881           else
3882             /* Just choose one.  */
3883             match = t;
3884
3885           if (match)
3886             t = OVL_CURRENT (match);
3887           else
3888             t = NULL_TREE;
3889         }
3890
3891       if (t == error_mark_node)
3892         {
3893           /* error_mark_node is 0 for a while during initialization!  */
3894           t = NULL_TREE;
3895           cp_error_at ("`%#D' used prior to declaration", x);
3896         }
3897       else if (t != NULL_TREE)
3898         {
3899           if (TREE_CODE (t) == PARM_DECL)
3900             {
3901               if (DECL_CONTEXT (t) == NULL_TREE)
3902                 fatal ("parse errors have confused me too much");
3903
3904               /* Check for duplicate params.  */
3905               if (duplicate_decls (x, t))
3906                 return t;
3907             }
3908           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3909                     || DECL_FUNCTION_TEMPLATE_P (x))
3910                    && is_overloaded_fn (t))
3911             /* Don't do anything just yet. */;
3912           else if (t == wchar_decl_node)
3913             {
3914               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3915                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3916
3917               /* Throw away the redeclaration.  */
3918               return t;
3919             }
3920           else if (TREE_CODE (t) != TREE_CODE (x))
3921             {
3922               if (duplicate_decls (x, t))
3923                 return t;
3924             }
3925           else if (duplicate_decls (x, t))
3926             {
3927               if (TREE_CODE (t) == TYPE_DECL)
3928                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3929               else if (TREE_CODE (t) == FUNCTION_DECL)
3930                 check_default_args (t);
3931
3932               return t;
3933             }
3934           else if (DECL_MAIN_P (x))
3935             {
3936               /* A redeclaration of main, but not a duplicate of the
3937                  previous one.
3938
3939                  [basic.start.main]
3940
3941                  This function shall not be overloaded.  */
3942               cp_error_at ("invalid redeclaration of `%D'", t);
3943               cp_error ("as `%D'", x);
3944               /* We don't try to push this declaration since that
3945                  causes a crash.  */
3946               return x;
3947             }
3948         }
3949
3950       check_template_shadow (x);
3951
3952       /* If this is a function conjured up by the backend, massage it
3953          so it looks friendly.  */
3954       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3955         {
3956           retrofit_lang_decl (x);
3957           DECL_LANGUAGE (x) = lang_c;
3958         }
3959
3960       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3961         {
3962           t = push_overloaded_decl (x, PUSH_LOCAL);
3963           if (t != x)
3964             return t;
3965           if (!namespace_bindings_p ())
3966             /* We do not need to create a binding for this name;
3967                push_overloaded_decl will have already done so if
3968                necessary.  */
3969             need_new_binding = 0;
3970         }
3971       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3972         {
3973           t = push_overloaded_decl (x, PUSH_GLOBAL);
3974           if (t == x)
3975             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3976           return t;
3977         }
3978
3979       /* If declaring a type as a typedef, copy the type (unless we're
3980          at line 0), and install this TYPE_DECL as the new type's typedef
3981          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3982       if (TREE_CODE (x) == TYPE_DECL)
3983         {
3984           tree type = TREE_TYPE (x);
3985           if (DECL_SOURCE_LINE (x) == 0)
3986             {
3987               if (TYPE_NAME (type) == 0)
3988                 TYPE_NAME (type) = x;
3989             }
3990           else if (type != error_mark_node && TYPE_NAME (type) != x
3991                    /* We don't want to copy the type when all we're
3992                       doing is making a TYPE_DECL for the purposes of
3993                       inlining.  */
3994                    && (!TYPE_NAME (type)
3995                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3996             {
3997               DECL_ORIGINAL_TYPE (x) = type;
3998               type = build_type_copy (type);
3999               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4000               TYPE_NAME (type) = x;
4001               TREE_TYPE (x) = type;
4002             }
4003
4004           if (type != error_mark_node
4005               && TYPE_NAME (type)
4006               && TYPE_IDENTIFIER (type))
4007             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4008                                                   current_binding_level);
4009
4010         }
4011
4012       /* Multiple external decls of the same identifier ought to match.
4013
4014          We get warnings about inline functions where they are defined.
4015          We get warnings about other functions from push_overloaded_decl.
4016
4017          Avoid duplicate warnings where they are used.  */
4018       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4019         {
4020           tree decl;
4021
4022           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
4023               && IDENTIFIER_NAMESPACE_VALUE (name) != error_mark_node
4024               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
4025                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
4026             decl = IDENTIFIER_NAMESPACE_VALUE (name);
4027           else
4028             decl = NULL_TREE;
4029
4030           if (decl
4031               /* If different sort of thing, we already gave an error.  */
4032               && TREE_CODE (decl) == TREE_CODE (x)
4033               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4034             {
4035               cp_pedwarn ("type mismatch with previous external decl", x);
4036               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4037             }
4038         }
4039
4040       /* This name is new in its binding level.
4041          Install the new declaration and return it.  */
4042       if (namespace_bindings_p ())
4043         {
4044           /* Install a global value.  */
4045
4046           /* If the first global decl has external linkage,
4047              warn if we later see static one.  */
4048           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4049             TREE_PUBLIC (name) = 1;
4050
4051           /* Bind the mangled name for the entity.  In the future, we
4052              should not need to do this; mangled names are an
4053              implementation detail of which the front-end should not
4054              need to be aware.  */
4055           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4056                 && t != NULL_TREE)
4057               /* For an ordinary function, we create a binding from
4058                  the mangled name (i.e., NAME) to the DECL.  But, for
4059                  an `extern "C"' function, the mangled name and the
4060                  ordinary name are the same so we need not do this.  */
4061               && !DECL_EXTERN_C_FUNCTION_P (x))
4062             {
4063               tree mangled_name;
4064
4065               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4066                   || TREE_CODE (x) == NAMESPACE_DECL)
4067                 mangled_name = name;
4068               else
4069                 mangled_name = DECL_ASSEMBLER_NAME (x);
4070
4071               if (TREE_CODE (x) == FUNCTION_DECL)
4072                 my_friendly_assert
4073                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4074                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4075               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4076             }
4077
4078           /* Don't forget if the function was used via an implicit decl.  */
4079           if (IDENTIFIER_IMPLICIT_DECL (name)
4080               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4081             TREE_USED (x) = 1;
4082
4083           /* Don't forget if its address was taken in that way.  */
4084           if (IDENTIFIER_IMPLICIT_DECL (name)
4085               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4086             TREE_ADDRESSABLE (x) = 1;
4087
4088           /* Warn about mismatches against previous implicit decl.  */
4089           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4090               /* If this real decl matches the implicit, don't complain.  */
4091               && ! (TREE_CODE (x) == FUNCTION_DECL
4092                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4093             cp_warning
4094               ("`%D' was previously implicitly declared to return `int'", x);
4095
4096           /* If new decl is `static' and an `extern' was seen previously,
4097              warn about it.  */
4098           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4099             warn_extern_redeclared_static (x, t);
4100         }
4101       else
4102         {
4103           /* Here to install a non-global value.  */
4104           tree oldlocal = IDENTIFIER_VALUE (name);
4105           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4106
4107           if (need_new_binding)
4108             {
4109               push_local_binding (name, x, 0);
4110               /* Because push_local_binding will hook X on to the
4111                  current_binding_level's name list, we don't want to
4112                  do that again below.  */
4113               need_new_binding = 0;
4114             }
4115
4116           /* If this is a TYPE_DECL, push it into the type value slot.  */
4117           if (TREE_CODE (x) == TYPE_DECL)
4118             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4119                                                   current_binding_level);
4120
4121           /* Clear out any TYPE_DECL shadowed by a namespace so that
4122              we won't think this is a type.  The C struct hack doesn't
4123              go through namespaces.  */
4124           if (TREE_CODE (x) == NAMESPACE_DECL)
4125             set_identifier_type_value_with_scope (name, NULL_TREE,
4126                                                   current_binding_level);
4127
4128           if (oldlocal)
4129             {
4130               tree d = oldlocal;
4131
4132               while (oldlocal
4133                      && TREE_CODE (oldlocal) == VAR_DECL
4134                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4135                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4136
4137               if (oldlocal == NULL_TREE)
4138                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4139             }
4140
4141           /* If this is an extern function declaration, see if we
4142              have a global definition or declaration for the function.  */
4143           if (oldlocal == NULL_TREE
4144               && DECL_EXTERNAL (x)
4145               && oldglobal != NULL_TREE
4146               && TREE_CODE (x) == FUNCTION_DECL
4147               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4148             {
4149               /* We have one.  Their types must agree.  */
4150               if (decls_match (x, oldglobal))
4151                 /* OK */;
4152               else
4153                 {
4154                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4155                   cp_warning_at ("global declaration `%#D'", oldglobal);
4156                 }
4157             }
4158           /* If we have a local external declaration,
4159              and no file-scope declaration has yet been seen,
4160              then if we later have a file-scope decl it must not be static.  */
4161           if (oldlocal == NULL_TREE
4162               && oldglobal == NULL_TREE
4163               && DECL_EXTERNAL (x)
4164               && TREE_PUBLIC (x))
4165             TREE_PUBLIC (name) = 1;
4166
4167           /* Warn if shadowing an argument at the top level of the body.  */
4168           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4169               /* Inline decls shadow nothing.  */
4170               && !DECL_FROM_INLINE (x)
4171               && TREE_CODE (oldlocal) == PARM_DECL
4172               /* Don't complain if it's from an enclosing function.  */
4173               && DECL_CONTEXT (oldlocal) == current_function_decl
4174               && TREE_CODE (x) != PARM_DECL)
4175             {
4176               /* Go to where the parms should be and see if we
4177                  find them there.  */
4178               struct binding_level *b = current_binding_level->level_chain;
4179
4180               if (cleanup_label)
4181                 b = b->level_chain;
4182
4183               /* ARM $8.3 */
4184               if (b->parm_flag == 1)
4185                 cp_error ("declaration of `%#D' shadows a parameter", name);
4186             }
4187
4188           /* Maybe warn if shadowing something else.  */
4189           if (warn_shadow && !DECL_EXTERNAL (x)
4190               /* Inline decls shadow nothing.  */
4191               && !DECL_FROM_INLINE (x)
4192               /* No shadow warnings for internally generated vars.  */
4193               && ! DECL_ARTIFICIAL (x)
4194               /* No shadow warnings for vars made for inlining.  */
4195               && ! DECL_FROM_INLINE (x))
4196             {
4197               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4198                 warning ("declaration of `%s' shadows a parameter",
4199                         IDENTIFIER_POINTER (name));
4200               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4201                        && current_class_ptr
4202                        && !TREE_STATIC (name))
4203                 warning ("declaration of `%s' shadows a member of `this'",
4204                         IDENTIFIER_POINTER (name));
4205               else if (oldlocal != NULL_TREE)
4206                 warning ("declaration of `%s' shadows previous local",
4207                         IDENTIFIER_POINTER (name));
4208               else if (oldglobal != NULL_TREE)
4209                 /* XXX shadow warnings in outer-more namespaces */
4210                 warning ("declaration of `%s' shadows global declaration",
4211                         IDENTIFIER_POINTER (name));
4212             }
4213         }
4214
4215       if (TREE_CODE (x) == FUNCTION_DECL)
4216         check_default_args (x);
4217
4218       /* Keep count of variables in this level with incomplete type.  */
4219       if (TREE_CODE (x) == VAR_DECL
4220           && TREE_TYPE (x) != error_mark_node
4221           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4222                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4223               /* RTTI TD entries are created while defining the type_info.  */
4224               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4225                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4226         {
4227           if (namespace_bindings_p ())
4228             namespace_scope_incomplete
4229               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4230           else
4231             current_binding_level->incomplete
4232               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4233         }
4234     }
4235
4236   if (need_new_binding)
4237     add_decl_to_level (x,
4238                        DECL_NAMESPACE_SCOPE_P (x)
4239                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4240                        : current_binding_level);
4241
4242   return x;
4243 }
4244
4245 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4246    caller to set DECL_CONTEXT properly.  */
4247
4248 static tree
4249 pushdecl_with_scope (x, level)
4250      tree x;
4251      struct binding_level *level;
4252 {
4253   register struct binding_level *b;
4254   tree function_decl = current_function_decl;
4255
4256   current_function_decl = NULL_TREE;
4257   if (level->parm_flag == 2)
4258     {
4259       b = class_binding_level;
4260       class_binding_level = level;
4261       pushdecl_class_level (x);
4262       class_binding_level = b;
4263     }
4264   else
4265     {
4266       b = current_binding_level;
4267       current_binding_level = level;
4268       x = pushdecl (x);
4269       current_binding_level = b;
4270     }
4271   current_function_decl = function_decl;
4272   return x;
4273 }
4274
4275 /* Like pushdecl, only it places X in the current namespace,
4276    if appropriate.  */
4277
4278 tree
4279 pushdecl_namespace_level (x)
4280      tree x;
4281 {
4282   register struct binding_level *b = current_binding_level;
4283   register tree t;
4284
4285   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4286
4287   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4288      what we want.  */
4289   if (TREE_CODE (x) == TYPE_DECL)
4290     {
4291       tree name = DECL_NAME (x);
4292       tree newval;
4293       tree *ptr = (tree *)0;
4294       for (; b != global_binding_level; b = b->level_chain)
4295         {
4296           tree shadowed = b->type_shadowed;
4297           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4298             if (TREE_PURPOSE (shadowed) == name)
4299               {
4300                 ptr = &TREE_VALUE (shadowed);
4301                 /* Can't break out of the loop here because sometimes
4302                    a binding level will have duplicate bindings for
4303                    PT names.  It's gross, but I haven't time to fix it.  */
4304               }
4305         }
4306       newval = TREE_TYPE (x);
4307       if (ptr == (tree *)0)
4308         {
4309           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4310              up here if this is changed to an assertion.  --KR  */
4311           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4312         }
4313       else
4314         {
4315           *ptr = newval;
4316         }
4317     }
4318   return t;
4319 }
4320
4321 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4322    if appropriate.  */
4323
4324 tree
4325 pushdecl_top_level (x)
4326      tree x;
4327 {
4328   push_to_top_level ();
4329   x = pushdecl_namespace_level (x);
4330   pop_from_top_level ();
4331   return x;
4332 }
4333
4334 /* Make the declaration of X appear in CLASS scope.  */
4335
4336 void
4337 pushdecl_class_level (x)
4338      tree x;
4339 {
4340   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4341      scope looks for the pre-mangled name.  */
4342   register tree name;
4343
4344   if (TREE_CODE (x) == OVERLOAD)
4345     x = OVL_CURRENT (x);
4346   name = DECL_NAME (x);
4347
4348   if (name)
4349     {
4350       push_class_level_binding (name, x);
4351       if (TREE_CODE (x) == TYPE_DECL)
4352         set_identifier_type_value (name, TREE_TYPE (x));
4353     }
4354   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4355     {
4356       tree f;
4357
4358       for (f = TYPE_FIELDS (TREE_TYPE (x));
4359            f;
4360            f = TREE_CHAIN (f))
4361         pushdecl_class_level (f);
4362     }
4363 }
4364
4365 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4366    DECL, or a modified version thereof.  */
4367
4368 tree
4369 maybe_push_decl (decl)
4370      tree decl;
4371 {
4372   tree type = TREE_TYPE (decl);
4373
4374   /* Add this decl to the current binding level, but not if it comes
4375      from another scope, e.g. a static member variable.  TEM may equal
4376      DECL or it may be a previous decl of the same name.  */
4377   if (decl == error_mark_node
4378       || (TREE_CODE (decl) != PARM_DECL
4379           && DECL_CONTEXT (decl) != NULL_TREE
4380           /* Definitions of namespace members outside their namespace are
4381              possible. */
4382           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4383       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4384       || TREE_CODE (type) == UNKNOWN_TYPE
4385       /* The declaration of a template specialization does not affect
4386          the functions available for overload resolution, so we do not
4387          call pushdecl.  */
4388       || (TREE_CODE (decl) == FUNCTION_DECL
4389           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4390     return decl;
4391   else
4392     return pushdecl (decl);
4393 }
4394
4395 /* Make the declaration(s) of X appear in CLASS scope
4396    under the name NAME.  */
4397
4398 void
4399 push_class_level_binding (name, x)
4400      tree name;
4401      tree x;
4402 {
4403   tree binding;
4404   /* The class_binding_level will be NULL if x is a template
4405      parameter name in a member template.  */
4406   if (!class_binding_level)
4407     return;
4408
4409   /* Make sure that this new member does not have the same name
4410      as a template parameter.  */
4411   if (TYPE_BEING_DEFINED (current_class_type))
4412     check_template_shadow (x);
4413
4414   /* If this declaration shadows a declaration from an enclosing
4415      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4416      we leave this class.  Record the shadowed declaration here.  */
4417   binding = IDENTIFIER_BINDING (name);
4418   if (binding
4419       && ((TREE_CODE (x) == OVERLOAD
4420            && BINDING_VALUE (binding)
4421            && is_overloaded_fn (BINDING_VALUE (binding)))
4422           || INHERITED_VALUE_BINDING_P (binding)))
4423     {
4424       tree shadow;
4425       tree old_decl;
4426
4427       /* If the old binding was from a base class, and was for a tag
4428          name, slide it over to make room for the new binding.  The
4429          old binding is still visible if explicitly qualified with a
4430          class-key.  */
4431       if (INHERITED_VALUE_BINDING_P (binding)
4432           && BINDING_VALUE (binding)
4433           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4434           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4435           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4436         {
4437           old_decl = BINDING_TYPE (binding);
4438           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4439           BINDING_VALUE (binding) = NULL_TREE;
4440           INHERITED_VALUE_BINDING_P (binding) = 0;
4441         }
4442       else
4443         old_decl = BINDING_VALUE (binding);
4444
4445       /* There was already a binding for X containing fewer
4446          functions than are named in X.  Find the previous
4447          declaration of X on the class-shadowed list, and update it.  */
4448       for (shadow = class_binding_level->class_shadowed;
4449            shadow;
4450            shadow = TREE_CHAIN (shadow))
4451         if (TREE_PURPOSE (shadow) == name
4452             && TREE_TYPE (shadow) == old_decl)
4453           {
4454             BINDING_VALUE (binding) = x;
4455             INHERITED_VALUE_BINDING_P (binding) = 0;
4456             TREE_TYPE (shadow) = x;
4457             return;
4458           }
4459     }
4460
4461   /* If we didn't replace an existing binding, put the binding on the
4462      stack of bindings for the identifier, and update
4463      IDENTIFIER_CLASS_VALUE.  */
4464   if (push_class_binding (name, x))
4465     {
4466       class_binding_level->class_shadowed
4467         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4468                      class_binding_level->class_shadowed);
4469       /* Record the value we are binding NAME to so that we can know
4470          what to pop later.  */
4471       TREE_TYPE (class_binding_level->class_shadowed) = x;
4472     }
4473 }
4474
4475 /* Insert another USING_DECL into the current binding level, returning
4476    this declaration. If this is a redeclaration, do nothing, and
4477    return NULL_TREE if this not in namespace scope (in namespace
4478    scope, a using decl might extend any previous bindings).  */
4479
4480 tree
4481 push_using_decl (scope, name)
4482      tree scope;
4483      tree name;
4484 {
4485   tree decl;
4486
4487   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4488   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4489   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4490     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4491       break;
4492   if (decl)
4493     return namespace_bindings_p () ? decl : NULL_TREE;
4494   decl = build_lang_decl (USING_DECL, name, void_type_node);
4495   DECL_INITIAL (decl) = scope;
4496   TREE_CHAIN (decl) = current_binding_level->usings;
4497   current_binding_level->usings = decl;
4498   return decl;
4499 }
4500
4501 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4502    changed (i.e. there was already a directive), or the fresh
4503    TREE_LIST otherwise.  */
4504
4505 tree
4506 push_using_directive (used)
4507      tree used;
4508 {
4509   tree ud = current_binding_level->using_directives;
4510   tree iter, ancestor;
4511
4512   /* Check if we already have this. */
4513   if (purpose_member (used, ud) != NULL_TREE)
4514     return NULL_TREE;
4515
4516   /* Recursively add all namespaces used. */
4517   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4518     push_using_directive (TREE_PURPOSE (iter));
4519
4520   ancestor = namespace_ancestor (current_decl_namespace (), used);
4521   ud = current_binding_level->using_directives;
4522   ud = tree_cons (used, ancestor, ud);
4523   current_binding_level->using_directives = ud;
4524   return ud;
4525 }
4526
4527 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4528    other definitions already in place.  We get around this by making
4529    the value of the identifier point to a list of all the things that
4530    want to be referenced by that name.  It is then up to the users of
4531    that name to decide what to do with that list.
4532
4533    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4534    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4535
4536    FLAGS is a bitwise-or of the following values:
4537      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4538                  namespace scope.
4539      PUSH_USING: DECL is being pushed as the result of a using
4540                  declaration.
4541
4542    The value returned may be a previous declaration if we guessed wrong
4543    about what language DECL should belong to (C or C++).  Otherwise,
4544    it's always DECL (and never something that's not a _DECL).  */
4545
4546 tree
4547 push_overloaded_decl (decl, flags)
4548      tree decl;
4549      int flags;
4550 {
4551   tree name = DECL_NAME (decl);
4552   tree old;
4553   tree new_binding;
4554   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4555
4556   if (doing_global)
4557     old = namespace_binding (name, DECL_CONTEXT (decl));
4558   else
4559     old = lookup_name_current_level (name);
4560
4561   if (old)
4562     {
4563       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4564         {
4565           tree t = TREE_TYPE (old);
4566           if (IS_AGGR_TYPE (t) && warn_shadow
4567               && (! DECL_IN_SYSTEM_HEADER (decl)
4568                   || ! DECL_IN_SYSTEM_HEADER (old)))
4569             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4570           old = NULL_TREE;
4571         }
4572       else if (is_overloaded_fn (old))
4573         {
4574           tree tmp;
4575
4576           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4577             {
4578               tree fn = OVL_CURRENT (tmp);
4579
4580               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4581                   && !(flags & PUSH_USING)
4582                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4583                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4584                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4585                           decl, fn);
4586
4587               if (duplicate_decls (decl, fn))
4588                 return fn;
4589             }
4590         }
4591       else if (old == error_mark_node)
4592         /* Ignore the undefined symbol marker.  */
4593         old = NULL_TREE;
4594       else
4595         {
4596           cp_error_at ("previous non-function declaration `%#D'", old);
4597           cp_error ("conflicts with function declaration `%#D'", decl);
4598           return decl;
4599         }
4600     }
4601
4602   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4603     {
4604       if (old && TREE_CODE (old) != OVERLOAD)
4605         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4606       else
4607         new_binding = ovl_cons (decl, old);
4608       if (flags & PUSH_USING)
4609         OVL_USED (new_binding) = 1;
4610     }
4611   else
4612     /* NAME is not ambiguous.  */
4613     new_binding = decl;
4614
4615   if (doing_global)
4616     set_namespace_binding (name, current_namespace, new_binding);
4617   else
4618     {
4619       /* We only create an OVERLOAD if there was a previous binding at
4620          this level, or if decl is a template. In the former case, we
4621          need to remove the old binding and replace it with the new
4622          binding.  We must also run through the NAMES on the binding
4623          level where the name was bound to update the chain.  */
4624
4625       if (TREE_CODE (new_binding) == OVERLOAD && old)
4626         {
4627           tree *d;
4628
4629           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4630                *d;
4631                d = &TREE_CHAIN (*d))
4632             if (*d == old
4633                 || (TREE_CODE (*d) == TREE_LIST
4634                     && TREE_VALUE (*d) == old))
4635               {
4636                 if (TREE_CODE (*d) == TREE_LIST)
4637                   /* Just replace the old binding with the new.  */
4638                   TREE_VALUE (*d) = new_binding;
4639                 else
4640                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4641                   *d = tree_cons (NULL_TREE, new_binding,
4642                                   TREE_CHAIN (*d));
4643
4644                 /* And update the CPLUS_BINDING node.  */
4645                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4646                   = new_binding;
4647                 return decl;
4648               }
4649
4650           /* We should always find a previous binding in this case.  */
4651           my_friendly_abort (0);
4652         }
4653
4654       /* Install the new binding.  */
4655       push_local_binding (name, new_binding, flags);
4656     }
4657
4658   return decl;
4659 }
4660 \f
4661 /* Generate an implicit declaration for identifier FUNCTIONID
4662    as a function of type int ().  Print a warning if appropriate.  */
4663
4664 tree
4665 implicitly_declare (functionid)
4666      tree functionid;
4667 {
4668   register tree decl;
4669
4670   /* We used to reuse an old implicit decl here,
4671      but this loses with inline functions because it can clobber
4672      the saved decl chains.  */
4673   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4674
4675   DECL_EXTERNAL (decl) = 1;
4676   TREE_PUBLIC (decl) = 1;
4677
4678   /* ISO standard says implicit declarations are in the innermost block.
4679      So we record the decl in the standard fashion.  */
4680   pushdecl (decl);
4681   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4682
4683   if (warn_implicit
4684       /* Only one warning per identifier.  */
4685       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4686     {
4687       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4688     }
4689
4690   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4691
4692   return decl;
4693 }
4694
4695 /* Return zero if the declaration NEWDECL is valid
4696    when the declaration OLDDECL (assumed to be for the same name)
4697    has already been seen.
4698    Otherwise return an error message format string with a %s
4699    where the identifier should go.  */
4700
4701 static const char *
4702 redeclaration_error_message (newdecl, olddecl)
4703      tree newdecl, olddecl;
4704 {
4705   if (TREE_CODE (newdecl) == TYPE_DECL)
4706     {
4707       /* Because C++ can put things into name space for free,
4708          constructs like "typedef struct foo { ... } foo"
4709          would look like an erroneous redeclaration.  */
4710       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4711         return 0;
4712       else
4713         return "redefinition of `%#D'";
4714     }
4715   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4716     {
4717       /* If this is a pure function, its olddecl will actually be
4718          the original initialization to `0' (which we force to call
4719          abort()).  Don't complain about redefinition in this case.  */
4720       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4721         return 0;
4722
4723       /* If both functions come from different namespaces, this is not
4724          a redeclaration - this is a conflict with a used function. */
4725       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4726           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4727         return "`%D' conflicts with used function";
4728
4729       /* We'll complain about linkage mismatches in
4730          warn_extern_redeclared_static.  */
4731
4732       /* Defining the same name twice is no good.  */
4733       if (DECL_INITIAL (olddecl) != NULL_TREE
4734           && DECL_INITIAL (newdecl) != NULL_TREE)
4735         {
4736           if (DECL_NAME (olddecl) == NULL_TREE)
4737             return "`%#D' not declared in class";
4738           else
4739             return "redefinition of `%#D'";
4740         }
4741       return 0;
4742     }
4743   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4744     {
4745       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4746            && (DECL_TEMPLATE_RESULT (newdecl)
4747                != DECL_TEMPLATE_RESULT (olddecl))
4748            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4749            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4750           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4751               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4752               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4753         return "redefinition of `%#D'";
4754       return 0;
4755     }
4756   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4757     {
4758       /* Objects declared at top level:  */
4759       /* If at least one is a reference, it's ok.  */
4760       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4761         return 0;
4762       /* Reject two definitions.  */
4763       return "redefinition of `%#D'";
4764     }
4765   else
4766     {
4767       /* Objects declared with block scope:  */
4768       /* Reject two definitions, and reject a definition
4769          together with an external reference.  */
4770       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4771         return "redeclaration of `%#D'";
4772       return 0;
4773     }
4774 }
4775 \f
4776 /* Create a new label, named ID.  */
4777
4778 static tree
4779 make_label_decl (id, local_p)
4780      tree id;
4781      int local_p;
4782 {
4783   tree decl;
4784
4785   decl = build_decl (LABEL_DECL, id, void_type_node);
4786   if (expanding_p)
4787     /* Make sure every label has an rtx.  */
4788     label_rtx (decl);
4789
4790   DECL_CONTEXT (decl) = current_function_decl;
4791   DECL_MODE (decl) = VOIDmode;
4792   C_DECLARED_LABEL_FLAG (decl) = local_p;
4793
4794   /* Say where one reference is to the label, for the sake of the
4795      error if it is not defined.  */
4796   DECL_SOURCE_LINE (decl) = lineno;
4797   DECL_SOURCE_FILE (decl) = input_filename;
4798
4799   /* Record the fact that this identifier is bound to this label.  */
4800   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4801
4802   return decl;
4803 }
4804
4805 /* Record this label on the list of used labels so that we can check
4806    at the end of the function to see whether or not the label was
4807    actually defined, and so we can check when the label is defined whether
4808    this use is valid.  */
4809
4810 static void
4811 use_label (decl)
4812      tree decl;
4813 {
4814   if (named_label_uses == NULL
4815       || named_label_uses->names_in_scope != current_binding_level->names
4816       || named_label_uses->label_decl != decl)
4817     {
4818       struct named_label_use_list *new_ent;
4819       new_ent = ((struct named_label_use_list *)
4820                  ggc_alloc (sizeof (struct named_label_use_list)));
4821       new_ent->label_decl = decl;
4822       new_ent->names_in_scope = current_binding_level->names;
4823       new_ent->binding_level = current_binding_level;
4824       new_ent->lineno_o_goto = lineno;
4825       new_ent->filename_o_goto = input_filename;
4826       new_ent->next = named_label_uses;
4827       named_label_uses = new_ent;
4828     }
4829 }
4830
4831 /* Look for a label named ID in the current function.  If one cannot
4832    be found, create one.  (We keep track of used, but undefined,
4833    labels, and complain about them at the end of a function.)  */
4834
4835 tree
4836 lookup_label (id)
4837      tree id;
4838 {
4839   tree decl;
4840   struct named_label_list *ent;
4841
4842   /* You can't use labels at global scope.  */
4843   if (current_function_decl == NULL_TREE)
4844     {
4845       error ("label `%s' referenced outside of any function",
4846              IDENTIFIER_POINTER (id));
4847       return NULL_TREE;
4848     }
4849
4850   /* See if we've already got this label.  */
4851   decl = IDENTIFIER_LABEL_VALUE (id);
4852   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4853     return decl;
4854
4855   /* Record this label on the list of labels used in this function.
4856      We do this before calling make_label_decl so that we get the
4857      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4858   ent = ((struct named_label_list *)
4859          ggc_alloc_cleared (sizeof (struct named_label_list)));
4860   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4861   ent->next = named_labels;
4862   named_labels = ent;
4863
4864   /* We need a new label.  */
4865   decl = make_label_decl (id, /*local_p=*/0);
4866
4867   /* Now fill in the information we didn't have before.  */
4868   ent->label_decl = decl;
4869
4870   return decl;
4871 }
4872
4873 /* Declare a local label named ID.  */
4874
4875 tree
4876 declare_local_label (id)
4877      tree id;
4878 {
4879   tree decl;
4880
4881   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4882      this scope we can restore the old value of
4883      IDENTIFIER_TYPE_VALUE.  */
4884   current_binding_level->shadowed_labels
4885     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4886                  current_binding_level->shadowed_labels);
4887   /* Look for the label.  */
4888   decl = make_label_decl (id, /*local_p=*/1);
4889   /* Now fill in the information we didn't have before.  */
4890   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4891
4892   return decl;
4893 }
4894
4895 /* Returns nonzero if it is ill-formed to jump past the declaration of
4896    DECL.  Returns 2 if it's also a real problem.  */
4897
4898 static int
4899 decl_jump_unsafe (decl)
4900      tree decl;
4901 {
4902   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4903     return 0;
4904
4905   if (DECL_INITIAL (decl) == NULL_TREE
4906       && pod_type_p (TREE_TYPE (decl)))
4907     return 0;
4908
4909   /* This is really only important if we're crossing an initialization.
4910      The POD stuff is just pedantry; why should it matter if the class
4911      contains a field of pointer to member type?  */
4912   if (DECL_INITIAL (decl)
4913       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4914     return 2;
4915   return 1;
4916 }
4917
4918 /* Check that a single previously seen jump to a newly defined label
4919    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4920    the jump context; NAMES are the names in scope in LEVEL at the jump
4921    context; FILE and LINE are the source position of the jump or 0.  */
4922
4923 static void
4924 check_previous_goto_1 (decl, level, names, file, line)
4925      tree decl;
4926      struct binding_level *level;
4927      tree names;
4928      const char *file;
4929      int line;
4930 {
4931   int identified = 0;
4932   int saw_eh = 0;
4933   struct binding_level *b = current_binding_level;
4934   for (; b; b = b->level_chain)
4935     {
4936       tree new_decls = b->names;
4937       tree old_decls = (b == level ? names : NULL_TREE);
4938       for (; new_decls != old_decls;
4939            new_decls = TREE_CHAIN (new_decls))
4940         {
4941           int problem = decl_jump_unsafe (new_decls);
4942           if (! problem)
4943             continue;
4944
4945           if (! identified)
4946             {
4947               if (decl)
4948                 cp_pedwarn ("jump to label `%D'", decl);
4949               else
4950                 pedwarn ("jump to case label");
4951
4952               if (file)
4953                 pedwarn_with_file_and_line (file, line, "  from here");
4954               identified = 1;
4955             }
4956
4957           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4958             /* Can't skip init of __exception_info.  */
4959             cp_error_at ("  enters catch block", new_decls);
4960           else if (problem > 1)
4961             cp_error_at ("  crosses initialization of `%#D'",
4962                          new_decls);
4963           else
4964             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4965                            new_decls);
4966         }
4967
4968       if (b == level)
4969         break;
4970       if (b->eh_region && ! saw_eh)
4971         {
4972           if (! identified)
4973             {
4974               if (decl)
4975                 cp_pedwarn ("jump to label `%D'", decl);
4976               else
4977                 pedwarn ("jump to case label");
4978
4979               if (file)
4980                 pedwarn_with_file_and_line (file, line, "  from here");
4981               identified = 1;
4982             }
4983           error ("  enters try block");
4984           saw_eh = 1;
4985         }
4986     }
4987 }
4988
4989 static void
4990 check_previous_goto (use)
4991      struct named_label_use_list *use;
4992 {
4993   check_previous_goto_1 (use->label_decl, use->binding_level,
4994                          use->names_in_scope, use->filename_o_goto,
4995                          use->lineno_o_goto);
4996 }
4997
4998 static void
4999 check_switch_goto (level)
5000      struct binding_level *level;
5001 {
5002   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5003 }
5004
5005 /* Check that any previously seen jumps to a newly defined label DECL
5006    are OK.  Called by define_label.  */
5007
5008 static void
5009 check_previous_gotos (decl)
5010      tree decl;
5011 {
5012   struct named_label_use_list **usep;
5013
5014   if (! TREE_USED (decl))
5015     return;
5016
5017   for (usep = &named_label_uses; *usep; )
5018     {
5019       struct named_label_use_list *use = *usep;
5020       if (use->label_decl == decl)
5021         {
5022           check_previous_goto (use);
5023           *usep = use->next;
5024         }
5025       else
5026         usep = &(use->next);
5027     }
5028 }
5029
5030 /* Check that a new jump to a label DECL is OK.  Called by
5031    finish_goto_stmt.  */
5032
5033 void
5034 check_goto (decl)
5035      tree decl;
5036 {
5037   int identified = 0;
5038   tree bad;
5039   struct named_label_list *lab;
5040
5041   /* We can't know where a computed goto is jumping.  So we assume
5042      that it's OK.  */
5043   if (! DECL_P (decl))
5044     return;
5045
5046   /* If the label hasn't been defined yet, defer checking.  */
5047   if (! DECL_INITIAL (decl))
5048     {
5049       use_label (decl);
5050       return;
5051     }
5052
5053   for (lab = named_labels; lab; lab = lab->next)
5054     if (decl == lab->label_decl)
5055       break;
5056
5057   /* If the label is not on named_labels it's a gcc local label, so
5058      it must be in an outer scope, so jumping to it is always OK.  */
5059   if (lab == 0)
5060     return;
5061
5062   if ((lab->eh_region || lab->bad_decls) && !identified)
5063     {
5064       cp_pedwarn_at ("jump to label `%D'", decl);
5065       pedwarn ("  from here");
5066       identified = 1;
5067     }
5068
5069   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5070     {
5071       tree b = TREE_VALUE (bad);
5072       int u = decl_jump_unsafe (b);
5073
5074       if (u > 1 && DECL_ARTIFICIAL (b))
5075         /* Can't skip init of __exception_info.  */
5076         cp_error_at ("  enters catch block", b);
5077       else if (u > 1)
5078         cp_error_at ("  skips initialization of `%#D'", b);
5079       else
5080         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5081     }
5082
5083   if (lab->eh_region)
5084     error ("  enters try block");
5085 }
5086
5087 /* Define a label, specifying the location in the source file.
5088    Return the LABEL_DECL node for the label, if the definition is valid.
5089    Otherwise return 0.  */
5090
5091 tree
5092 define_label (filename, line, name)
5093      const char *filename;
5094      int line;
5095      tree name;
5096 {
5097   tree decl = lookup_label (name);
5098   struct named_label_list *ent;
5099
5100   for (ent = named_labels; ent; ent = ent->next)
5101     if (ent->label_decl == decl)
5102       break;
5103
5104   /* After labels, make any new cleanups go into their
5105      own new (temporary) binding contour.  */
5106   current_binding_level->more_cleanups_ok = 0;
5107
5108   if (name == get_identifier ("wchar_t"))
5109     cp_pedwarn ("label named wchar_t");
5110
5111   if (DECL_INITIAL (decl) != NULL_TREE)
5112     {
5113       cp_error ("duplicate label `%D'", decl);
5114       return 0;
5115     }
5116   else
5117     {
5118       /* Mark label as having been defined.  */
5119       DECL_INITIAL (decl) = error_mark_node;
5120       /* Say where in the source.  */
5121       DECL_SOURCE_FILE (decl) = filename;
5122       DECL_SOURCE_LINE (decl) = line;
5123       if (ent)
5124         {
5125           ent->names_in_scope = current_binding_level->names;
5126           ent->binding_level = current_binding_level;
5127         }
5128       check_previous_gotos (decl);
5129       current_function_return_value = NULL_TREE;
5130       return decl;
5131     }
5132 }
5133
5134 struct cp_switch
5135 {
5136   struct binding_level *level;
5137   struct cp_switch *next;
5138 };
5139
5140 static struct cp_switch *switch_stack;
5141
5142 void
5143 push_switch ()
5144 {
5145   struct cp_switch *p
5146     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5147   p->level = current_binding_level;
5148   p->next = switch_stack;
5149   switch_stack = p;
5150 }
5151
5152 void
5153 pop_switch ()
5154 {
5155   struct cp_switch *cs;
5156
5157   cs = switch_stack;
5158   switch_stack = switch_stack->next;
5159   free (cs);
5160 }
5161
5162 /* Note that we've seen a definition of a case label, and complain if this
5163    is a bad place for one.  */
5164
5165 void
5166 define_case_label ()
5167 {
5168   tree cleanup = last_cleanup_this_contour ();
5169
5170   if (! switch_stack)
5171     /* Don't crash; we'll complain in do_case.  */
5172     return;
5173
5174   if (cleanup)
5175     {
5176       static int explained = 0;
5177       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5178       warning ("where case label appears here");
5179       if (!explained)
5180         {
5181           warning ("(enclose actions of previous case statements requiring");
5182           warning ("destructors in their own binding contours.)");
5183           explained = 1;
5184         }
5185     }
5186
5187   check_switch_goto (switch_stack->level);
5188
5189   /* After labels, make any new cleanups go into their
5190      own new (temporary) binding contour.  */
5191
5192   current_binding_level->more_cleanups_ok = 0;
5193   current_function_return_value = NULL_TREE;
5194 }
5195 \f
5196 /* Return the list of declarations of the current level.
5197    Note that this list is in reverse order unless/until
5198    you nreverse it; and when you do nreverse it, you must
5199    store the result back using `storedecls' or you will lose.  */
5200
5201 tree
5202 getdecls ()
5203 {
5204   return current_binding_level->names;
5205 }
5206
5207 /* Return the list of type-tags (for structs, etc) of the current level.  */
5208
5209 tree
5210 gettags ()
5211 {
5212   return current_binding_level->tags;
5213 }
5214
5215 /* Store the list of declarations of the current level.
5216    This is done for the parameter declarations of a function being defined,
5217    after they are modified in the light of any missing parameters.  */
5218
5219 static void
5220 storedecls (decls)
5221      tree decls;
5222 {
5223   current_binding_level->names = decls;
5224 }
5225
5226 /* Similarly, store the list of tags of the current level.  */
5227
5228 void
5229 storetags (tags)
5230      tree tags;
5231 {
5232   current_binding_level->tags = tags;
5233 }
5234 \f
5235 /* Given NAME, an IDENTIFIER_NODE,
5236    return the structure (or union or enum) definition for that name.
5237    Searches binding levels from BINDING_LEVEL up to the global level.
5238    If THISLEVEL_ONLY is nonzero, searches only the specified context
5239    (but skips any tag-transparent contexts to find one that is
5240    meaningful for tags).
5241    FORM says which kind of type the caller wants;
5242    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5243    If the wrong kind of type is found, and it's not a template, an error is
5244    reported.  */
5245
5246 static tree
5247 lookup_tag (form, name, binding_level, thislevel_only)
5248      enum tree_code form;
5249      tree name;
5250      struct binding_level *binding_level;
5251      int thislevel_only;
5252 {
5253   register struct binding_level *level;
5254   /* Non-zero if, we should look past a template parameter level, even
5255      if THISLEVEL_ONLY.  */
5256   int allow_template_parms_p = 1;
5257
5258   for (level = binding_level; level; level = level->level_chain)
5259     {
5260       register tree tail;
5261       if (ANON_AGGRNAME_P (name))
5262         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5263           {
5264             /* There's no need for error checking here, because
5265                anon names are unique throughout the compilation.  */
5266             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5267               return TREE_VALUE (tail);
5268           }
5269       else if (level->namespace_p)
5270         /* Do namespace lookup. */
5271         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5272           {
5273             tree old = binding_for_name (name, tail);
5274
5275             /* If we just skipped past a template parameter level,
5276                even though THISLEVEL_ONLY, and we find a template
5277                class declaration, then we use the _TYPE node for the
5278                template.  See the example below.  */
5279             if (thislevel_only && !allow_template_parms_p
5280                 && old && BINDING_VALUE (old)
5281                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5282               old = TREE_TYPE (BINDING_VALUE (old));
5283             else
5284               old = BINDING_TYPE (old);
5285
5286             /* If it has an original type, it is a typedef, and we
5287                should not return it.  */
5288             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5289               old = NULL_TREE;
5290             if (old && TREE_CODE (old) != form
5291                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5292               {
5293                 cp_error ("`%#D' redeclared as %C", old, form);
5294                 return NULL_TREE;
5295               }
5296             if (old)
5297               return old;
5298             if (thislevel_only || tail == global_namespace)
5299               return NULL_TREE;
5300           }
5301       else
5302         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5303           {
5304             if (TREE_PURPOSE (tail) == name)
5305               {
5306                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5307                 /* Should tighten this up; it'll probably permit
5308                    UNION_TYPE and a struct template, for example.  */
5309                 if (code != form
5310                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5311                   {
5312                     /* Definition isn't the kind we were looking for.  */
5313                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5314                               form);
5315                     return NULL_TREE;
5316                   }
5317                 return TREE_VALUE (tail);
5318               }
5319           }
5320       if (thislevel_only && ! level->tag_transparent)
5321         {
5322           if (level->template_parms_p && allow_template_parms_p)
5323             {
5324               /* We must deal with cases like this:
5325
5326                    template <class T> struct S;
5327                    template <class T> struct S {};
5328
5329                  When looking up `S', for the second declaration, we
5330                  would like to find the first declaration.  But, we
5331                  are in the pseudo-global level created for the
5332                  template parameters, rather than the (surrounding)
5333                  namespace level.  Thus, we keep going one more level,
5334                  even though THISLEVEL_ONLY is non-zero.  */
5335               allow_template_parms_p = 0;
5336               continue;
5337             }
5338           else
5339             return NULL_TREE;
5340         }
5341     }
5342   return NULL_TREE;
5343 }
5344
5345 #if 0
5346 void
5347 set_current_level_tags_transparency (tags_transparent)
5348      int tags_transparent;
5349 {
5350   current_binding_level->tag_transparent = tags_transparent;
5351 }
5352 #endif
5353
5354 /* Given a type, find the tag that was defined for it and return the tag name.
5355    Otherwise return 0.  However, the value can never be 0
5356    in the cases in which this is used.
5357
5358    C++: If NAME is non-zero, this is the new name to install.  This is
5359    done when replacing anonymous tags with real tag names.  */
5360
5361 static tree
5362 lookup_tag_reverse (type, name)
5363      tree type;
5364      tree name;
5365 {
5366   register struct binding_level *level;
5367
5368   for (level = current_binding_level; level; level = level->level_chain)
5369     {
5370       register tree tail;
5371       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5372         {
5373           if (TREE_VALUE (tail) == type)
5374             {
5375               if (name)
5376                 TREE_PURPOSE (tail) = name;
5377               return TREE_PURPOSE (tail);
5378             }
5379         }
5380     }
5381   return NULL_TREE;
5382 }
5383 \f
5384 /* Look up NAME in the NAMESPACE.  */
5385
5386 tree
5387 lookup_namespace_name (namespace, name)
5388      tree namespace, name;
5389 {
5390   tree val;
5391   tree template_id = NULL_TREE;
5392
5393   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5394
5395   if (TREE_CODE (name) == NAMESPACE_DECL)
5396     /* This happens for A::B<int> when B is a namespace. */
5397     return name;
5398   else if (TREE_CODE (name) == TEMPLATE_DECL)
5399     {
5400       /* This happens for A::B where B is a template, and there are no
5401          template arguments.  */
5402       cp_error ("invalid use of `%D'", name);
5403       return error_mark_node;
5404     }
5405
5406   namespace = ORIGINAL_NAMESPACE (namespace);
5407
5408   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5409     {
5410       template_id = name;
5411       name = TREE_OPERAND (name, 0);
5412       if (TREE_CODE (name) == OVERLOAD)
5413         name = DECL_NAME (OVL_CURRENT (name));
5414       else if (DECL_P (name))
5415         name = DECL_NAME (name);
5416     }
5417
5418   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5419
5420   val = make_node (CPLUS_BINDING);
5421   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5422     return error_mark_node;
5423
5424   if (BINDING_VALUE (val))
5425     {
5426       val = BINDING_VALUE (val);
5427
5428       if (template_id)
5429         {
5430           if (DECL_CLASS_TEMPLATE_P (val))
5431             val = lookup_template_class (val,
5432                                          TREE_OPERAND (template_id, 1),
5433                                          /*in_decl=*/NULL_TREE,
5434                                          /*context=*/NULL_TREE,
5435                                          /*entering_scope=*/0);
5436           else if (DECL_FUNCTION_TEMPLATE_P (val)
5437                    || TREE_CODE (val) == OVERLOAD)
5438             val = lookup_template_function (val,
5439                                             TREE_OPERAND (template_id, 1));
5440           else
5441             {
5442               cp_error ("`%D::%D' is not a template",
5443                         namespace, name);
5444               return error_mark_node;
5445             }
5446         }
5447
5448       /* If we have a single function from a using decl, pull it out.  */
5449       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5450         val = OVL_FUNCTION (val);
5451       return val;
5452     }
5453
5454   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5455   return error_mark_node;
5456 }
5457
5458 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5459
5460 static unsigned long
5461 typename_hash (k)
5462      hash_table_key k;
5463 {
5464   unsigned long hash;
5465   tree t;
5466
5467   t = (tree) k;
5468   hash = (((unsigned long) TYPE_CONTEXT (t))
5469           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5470
5471   return hash;
5472 }
5473
5474 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5475
5476 static boolean
5477 typename_compare (k1, k2)
5478      hash_table_key k1;
5479      hash_table_key k2;
5480 {
5481   tree t1;
5482   tree t2;
5483   tree d1;
5484   tree d2;
5485
5486   t1 = (tree) k1;
5487   t2 = (tree) k2;
5488   d1 = TYPE_NAME (t1);
5489   d2 = TYPE_NAME (t2);
5490
5491   return (DECL_NAME (d1) == DECL_NAME (d2)
5492           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5493           && ((TREE_TYPE (t1) != NULL_TREE)
5494               == (TREE_TYPE (t2) != NULL_TREE))
5495           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5496           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5497 }
5498
5499 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5500    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5501    is non-NULL, this type is being created by the implicit typename
5502    extension, and BASE_TYPE is a type named `t' in some base class of
5503    `T' which depends on template parameters.
5504
5505    Returns the new TYPENAME_TYPE.  */
5506
5507 tree
5508 build_typename_type (context, name, fullname, base_type)
5509      tree context;
5510      tree name;
5511      tree fullname;
5512      tree base_type;
5513 {
5514   tree t;
5515   tree d;
5516   struct hash_entry* e;
5517
5518   static struct hash_table ht;
5519
5520   if (!ht.table)
5521     {
5522       static struct hash_table *h = &ht;
5523       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5524                             &typename_compare))
5525         fatal ("virtual memory exhausted");
5526       ggc_add_tree_hash_table_root (&h, 1);
5527     }
5528
5529   /* Build the TYPENAME_TYPE.  */
5530   t = make_aggr_type (TYPENAME_TYPE);
5531   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5532   TYPENAME_TYPE_FULLNAME (t) = fullname;
5533   TREE_TYPE (t) = base_type;
5534
5535   /* Build the corresponding TYPE_DECL.  */
5536   d = build_decl (TYPE_DECL, name, t);
5537   TYPE_NAME (TREE_TYPE (d)) = d;
5538   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5539   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5540   DECL_ARTIFICIAL (d) = 1;
5541
5542   /* See if we already have this type.  */
5543   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5544   if (e)
5545     t = (tree) e->key;
5546   else
5547     /* Insert the type into the table.  */
5548     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5549
5550   return t;
5551 }
5552
5553 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5554    unless an error occurs, in which case error_mark_node is returned.
5555    If COMPLAIN zero, don't complain about any errors that occur.  */
5556
5557 tree
5558 make_typename_type (context, name, complain)
5559      tree context, name;
5560      int complain;
5561 {
5562   tree fullname;
5563
5564   if (TYPE_P (name))
5565     {
5566       if (!(TYPE_LANG_SPECIFIC (name)
5567             && (CLASSTYPE_IS_TEMPLATE (name)
5568                 || CLASSTYPE_USE_TEMPLATE (name))))
5569         name = TYPE_IDENTIFIER (name);
5570       else
5571         /* Create a TEMPLATE_ID_EXPR for the type.  */
5572         name = build_nt (TEMPLATE_ID_EXPR,
5573                          CLASSTYPE_TI_TEMPLATE (name),
5574                          CLASSTYPE_TI_ARGS (name));
5575     }
5576   else if (TREE_CODE (name) == TYPE_DECL)
5577     name = DECL_NAME (name);
5578
5579   fullname = name;
5580
5581   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5582     {
5583       name = TREE_OPERAND (name, 0);
5584       if (TREE_CODE (name) == TEMPLATE_DECL)
5585         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5586     }
5587   if (TREE_CODE (name) != IDENTIFIER_NODE)
5588     my_friendly_abort (2000);
5589
5590   if (TREE_CODE (context) == NAMESPACE_DECL)
5591     {
5592       /* We can get here from typename_sub0 in the explicit_template_type
5593          expansion.  Just fail.  */
5594       if (complain)
5595         cp_error ("no class template named `%#T' in `%#T'",
5596                   name, context);
5597       return error_mark_node;
5598     }
5599
5600   if (! uses_template_parms (context)
5601       || currently_open_class (context))
5602     {
5603       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5604         {
5605           tree tmpl = NULL_TREE;
5606           if (IS_AGGR_TYPE (context))
5607             tmpl = lookup_field (context, name, 0, 0);
5608           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5609             {
5610               if (complain)
5611                 cp_error ("no class template named `%#T' in `%#T'",
5612                           name, context);
5613               return error_mark_node;
5614             }
5615
5616           return lookup_template_class (tmpl,
5617                                         TREE_OPERAND (fullname, 1),
5618                                         NULL_TREE, context,
5619                                         /*entering_scope=*/0);
5620         }
5621       else
5622         {
5623           tree t;
5624
5625           if (!IS_AGGR_TYPE (context))
5626             {
5627               if (complain)
5628                 cp_error ("no type named `%#T' in `%#T'", name, context);
5629               return error_mark_node;
5630             }
5631
5632           t = lookup_field (context, name, 0, 1);
5633           if (t)
5634             return TREE_TYPE (t);
5635         }
5636     }
5637
5638   /* If the CONTEXT is not a template type, then either the field is
5639      there now or its never going to be.  */
5640   if (!uses_template_parms (context))
5641     {
5642       if (complain)
5643         cp_error ("no type named `%#T' in `%#T'", name, context);
5644       return error_mark_node;
5645     }
5646
5647
5648   return build_typename_type (context, name, fullname,  NULL_TREE);
5649 }
5650
5651 /* Select the right _DECL from multiple choices. */
5652
5653 static tree
5654 select_decl (binding, flags)
5655      tree binding;
5656      int flags;
5657 {
5658   tree val;
5659   val = BINDING_VALUE (binding);
5660   if (LOOKUP_NAMESPACES_ONLY (flags))
5661     {
5662       /* We are not interested in types. */
5663       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5664         return val;
5665       return NULL_TREE;
5666     }
5667
5668   /* If we could have a type and
5669      we have nothing or we need a type and have none.  */
5670   if (BINDING_TYPE (binding)
5671       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5672                    && TREE_CODE (val) != TYPE_DECL)))
5673     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5674   /* Don't return non-types if we really prefer types. */
5675   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5676            && (TREE_CODE (val) != TEMPLATE_DECL
5677                || !DECL_CLASS_TEMPLATE_P (val)))
5678     val = NULL_TREE;
5679
5680   return val;
5681 }
5682
5683 /* Unscoped lookup of a global: iterate over current namespaces,
5684    considering using-directives.  If SPACESP is non-NULL, store a list
5685    of the namespaces we've considered in it.  */
5686
5687 tree
5688 unqualified_namespace_lookup (name, flags, spacesp)
5689      tree name;
5690      int flags;
5691      tree *spacesp;
5692 {
5693   tree b = make_node (CPLUS_BINDING);
5694   tree initial = current_decl_namespace();
5695   tree scope = initial;
5696   tree siter;
5697   struct binding_level *level;
5698   tree val = NULL_TREE;
5699
5700   if (spacesp)
5701     *spacesp = NULL_TREE;
5702
5703   for (; !val; scope = CP_DECL_CONTEXT (scope))
5704     {
5705       if (spacesp)
5706         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5707       val = binding_for_name (name, scope);
5708
5709       /* Initialize binding for this context. */
5710       BINDING_VALUE (b) = BINDING_VALUE (val);
5711       BINDING_TYPE (b) = BINDING_TYPE (val);
5712
5713       /* Add all _DECLs seen through local using-directives. */
5714       for (level = current_binding_level;
5715            !level->namespace_p;
5716            level = level->level_chain)
5717         if (!lookup_using_namespace (name, b, level->using_directives,
5718                                      scope, flags, spacesp))
5719           /* Give up because of error. */
5720           return error_mark_node;
5721
5722       /* Add all _DECLs seen through global using-directives. */
5723       /* XXX local and global using lists should work equally. */
5724       siter = initial;
5725       while (1)
5726         {
5727           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5728                                        scope, flags, spacesp))
5729             /* Give up because of error. */
5730             return error_mark_node;
5731           if (siter == scope) break;
5732           siter = CP_DECL_CONTEXT (siter);
5733         }
5734
5735       val = select_decl (b, flags);
5736       if (scope == global_namespace)
5737         break;
5738     }
5739   return val;
5740 }
5741
5742 /* Combine prefer_type and namespaces_only into flags.  */
5743
5744 static int
5745 lookup_flags (prefer_type, namespaces_only)
5746   int prefer_type, namespaces_only;
5747 {
5748   if (namespaces_only)
5749     return LOOKUP_PREFER_NAMESPACES;
5750   if (prefer_type > 1)
5751     return LOOKUP_PREFER_TYPES;
5752   if (prefer_type > 0)
5753     return LOOKUP_PREFER_BOTH;
5754   return 0;
5755 }
5756
5757 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5758    ignore it or not.  Subroutine of lookup_name_real.  */
5759
5760 static tree
5761 qualify_lookup (val, flags)
5762      tree val;
5763      int flags;
5764 {
5765   if (val == NULL_TREE)
5766     return val;
5767   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5768     return val;
5769   if ((flags & LOOKUP_PREFER_TYPES)
5770       && (TREE_CODE (val) == TYPE_DECL
5771           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5772               && DECL_CLASS_TEMPLATE_P (val))))
5773     return val;
5774   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5775     return NULL_TREE;
5776   return val;
5777 }
5778
5779 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5780    that.  */
5781
5782 static void
5783 warn_about_implicit_typename_lookup (typename, binding)
5784      tree typename;
5785      tree binding;
5786 {
5787   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5788   tree name = DECL_NAME (typename);
5789
5790   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5791          && CLASSTYPE_TEMPLATE_INFO (subtype)
5792          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5793       && ! (TREE_CODE (binding) == TYPE_DECL
5794             && same_type_p (TREE_TYPE (binding), subtype)))
5795     {
5796       cp_warning ("lookup of `%D' finds `%#D'",
5797                   name, binding);
5798       cp_warning ("  instead of `%D' from dependent base class",
5799                   typename);
5800       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5801                   constructor_name (current_class_type), name);
5802     }
5803 }
5804
5805 /* Look up NAME in the current binding level and its superiors in the
5806    namespace of variables, functions and typedefs.  Return a ..._DECL
5807    node of some kind representing its definition if there is only one
5808    such declaration, or return a TREE_LIST with all the overloaded
5809    definitions if there are many, or return 0 if it is undefined.
5810
5811    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5812    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5813    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5814    Otherwise we prefer non-TYPE_DECLs.
5815
5816    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5817    using IDENTIFIER_CLASS_VALUE.  */
5818
5819 static tree
5820 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5821      tree name;
5822      int prefer_type, nonclass, namespaces_only;
5823 {
5824   tree t;
5825   tree val = NULL_TREE;
5826   int yylex = 0;
5827   tree from_obj = NULL_TREE;
5828   int flags;
5829   int val_is_implicit_typename = 0;
5830
5831   /* Hack: copy flag set by parser, if set. */
5832   if (only_namespace_names)
5833     namespaces_only = 1;
5834
5835   if (prefer_type == -2)
5836     {
5837       extern int looking_for_typename;
5838       tree type = NULL_TREE;
5839
5840       yylex = 1;
5841       prefer_type = looking_for_typename;
5842
5843       flags = lookup_flags (prefer_type, namespaces_only);
5844       /* If the next thing is '<', class templates are types. */
5845       if (looking_for_template)
5846         flags |= LOOKUP_TEMPLATES_EXPECTED;
5847
5848       /* std:: becomes :: for now.  */
5849       if (got_scope == std_node)
5850         got_scope = void_type_node;
5851
5852       if (got_scope)
5853         type = got_scope;
5854       else if (got_object != error_mark_node)
5855         type = got_object;
5856
5857       if (type)
5858         {
5859           if (type == error_mark_node)
5860             return error_mark_node;
5861           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5862             type = TREE_TYPE (type);
5863
5864           if (TYPE_P (type))
5865             type = complete_type (type);
5866
5867           if (TREE_CODE (type) == VOID_TYPE)
5868             type = global_namespace;
5869           if (TREE_CODE (type) == NAMESPACE_DECL)
5870             {
5871               val = make_node (CPLUS_BINDING);
5872               flags |= LOOKUP_COMPLAIN;
5873               if (!qualified_lookup_using_namespace (name, type, val, flags))
5874                 return NULL_TREE;
5875               val = select_decl (val, flags);
5876             }
5877           else if (! IS_AGGR_TYPE (type)
5878                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5879                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5880                    || TREE_CODE (type) == TYPENAME_TYPE)
5881             /* Someone else will give an error about this if needed.  */
5882             val = NULL_TREE;
5883           else if (type == current_class_type)
5884             val = IDENTIFIER_CLASS_VALUE (name);
5885           else
5886             {
5887               val = lookup_member (type, name, 0, prefer_type);
5888               type_access_control (type, val);
5889             }
5890         }
5891       else
5892         val = NULL_TREE;
5893
5894       if (got_scope)
5895         goto done;
5896       else if (got_object && val)
5897         from_obj = val;
5898     }
5899   else
5900     {
5901       flags = lookup_flags (prefer_type, namespaces_only);
5902       /* If we're not parsing, we need to complain. */
5903       flags |= LOOKUP_COMPLAIN;
5904     }
5905
5906   /* First, look in non-namespace scopes.  */
5907
5908   if (current_class_type == NULL_TREE)
5909     nonclass = 1;
5910
5911   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5912     {
5913       tree binding;
5914
5915       if (!LOCAL_BINDING_P (t) && nonclass)
5916         /* We're not looking for class-scoped bindings, so keep going.  */
5917         continue;
5918
5919       /* If this is the kind of thing we're looking for, we're done.  */
5920       if (qualify_lookup (BINDING_VALUE (t), flags))
5921         binding = BINDING_VALUE (t);
5922       else if ((flags & LOOKUP_PREFER_TYPES)
5923                && qualify_lookup (BINDING_TYPE (t), flags))
5924         binding = BINDING_TYPE (t);
5925       else
5926         binding = NULL_TREE;
5927
5928       /* Handle access control on types from enclosing or base classes.  */
5929       if (binding && ! yylex
5930           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5931         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5932
5933       if (binding
5934           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5935         {
5936           if (val_is_implicit_typename && !yylex)
5937             warn_about_implicit_typename_lookup (val, binding);
5938           val = binding;
5939           val_is_implicit_typename
5940             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5941           if (!val_is_implicit_typename)
5942             break;
5943         }
5944     }
5945
5946   /* Now lookup in namespace scopes.  */
5947   if (!val || val_is_implicit_typename)
5948     {
5949       t = unqualified_namespace_lookup (name, flags, 0);
5950       if (t)
5951         {
5952           if (val_is_implicit_typename && !yylex)
5953             warn_about_implicit_typename_lookup (val, t);
5954           val = t;
5955         }
5956     }
5957
5958  done:
5959   if (val)
5960     {
5961       /* This should only warn about types used in qualified-ids.  */
5962       if (from_obj && from_obj != val)
5963         {
5964           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5965               && TREE_CODE (val) == TYPE_DECL
5966               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5967             {
5968               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5969                           name, got_object, TREE_TYPE (from_obj));
5970               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5971                           TREE_TYPE (val));
5972             }
5973
5974           /* We don't change val to from_obj if got_object depends on
5975              template parms because that breaks implicit typename for
5976              destructor calls.  */
5977           if (! uses_template_parms (got_object))
5978             val = from_obj;
5979         }
5980
5981       /* If we have a single function from a using decl, pull it out.  */
5982       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5983         val = OVL_FUNCTION (val);
5984     }
5985   else if (from_obj)
5986     val = from_obj;
5987
5988   return val;
5989 }
5990
5991 tree
5992 lookup_name_nonclass (name)
5993      tree name;
5994 {
5995   return lookup_name_real (name, 0, 1, 0);
5996 }
5997
5998 tree
5999 lookup_function_nonclass (name, args)
6000      tree name;
6001      tree args;
6002 {
6003   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6004 }
6005
6006 tree
6007 lookup_name_namespace_only (name)
6008      tree name;
6009 {
6010   /* type-or-namespace, nonclass, namespace_only */
6011   return lookup_name_real (name, 1, 1, 1);
6012 }
6013
6014 tree
6015 lookup_name (name, prefer_type)
6016      tree name;
6017      int prefer_type;
6018 {
6019   return lookup_name_real (name, prefer_type, 0, 0);
6020 }
6021
6022 /* Similar to `lookup_name' but look only in the innermost non-class
6023    binding level.  */
6024
6025 tree
6026 lookup_name_current_level (name)
6027      tree name;
6028 {
6029   struct binding_level *b;
6030   tree t = NULL_TREE;
6031
6032   b = current_binding_level;
6033   while (b->parm_flag == 2)
6034     b = b->level_chain;
6035
6036   if (b->namespace_p)
6037     {
6038       t = IDENTIFIER_NAMESPACE_VALUE (name);
6039
6040       /* extern "C" function() */
6041       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6042         t = TREE_VALUE (t);
6043     }
6044   else if (IDENTIFIER_BINDING (name)
6045            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6046     {
6047       while (1)
6048         {
6049           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6050             return IDENTIFIER_VALUE (name);
6051
6052           if (b->keep == 2)
6053             b = b->level_chain;
6054           else
6055             break;
6056         }
6057     }
6058
6059   return t;
6060 }
6061
6062 /* Like lookup_name_current_level, but for types.  */
6063
6064 tree
6065 lookup_type_current_level (name)
6066      tree name;
6067 {
6068   register tree t = NULL_TREE;
6069
6070   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6071
6072   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6073       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6074     {
6075       struct binding_level *b = current_binding_level;
6076       while (1)
6077         {
6078           if (purpose_member (name, b->type_shadowed))
6079             return REAL_IDENTIFIER_TYPE_VALUE (name);
6080           if (b->keep == 2)
6081             b = b->level_chain;
6082           else
6083             break;
6084         }
6085     }
6086
6087   return t;
6088 }
6089
6090 void
6091 begin_only_namespace_names ()
6092 {
6093   only_namespace_names = 1;
6094 }
6095
6096 void
6097 end_only_namespace_names ()
6098 {
6099   only_namespace_names = 0;
6100 }
6101 \f
6102 /* Arrange for the user to get a source line number, even when the
6103    compiler is going down in flames, so that she at least has a
6104    chance of working around problems in the compiler.  We used to
6105    call error(), but that let the segmentation fault continue
6106    through; now, it's much more passive by asking them to send the
6107    maintainers mail about the problem.  */
6108
6109 static void
6110 signal_catch (sig)
6111      int sig ATTRIBUTE_UNUSED;
6112 {
6113   signal (SIGSEGV, SIG_DFL);
6114 #ifdef SIGIOT
6115   signal (SIGIOT, SIG_DFL);
6116 #endif
6117 #ifdef SIGILL
6118   signal (SIGILL, SIG_DFL);
6119 #endif
6120 #ifdef SIGABRT
6121   signal (SIGABRT, SIG_DFL);
6122 #endif
6123 #ifdef SIGBUS
6124   signal (SIGBUS, SIG_DFL);
6125 #endif
6126   my_friendly_abort (0);
6127 }
6128
6129 /* Push the declarations of builtin types into the namespace.
6130    RID_INDEX, if < CP_RID_MAX is the index of the builtin type
6131    in the array RID_POINTERS.  NAME is the name used when looking
6132    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6133
6134 static void
6135 record_builtin_type (rid_index, name, type)
6136      enum rid rid_index;
6137      const char *name;
6138      tree type;
6139 {
6140   tree rname = NULL_TREE, tname = NULL_TREE;
6141   tree tdecl = NULL_TREE;
6142
6143   if ((int) rid_index < (int) CP_RID_MAX)
6144     rname = ridpointers[(int) rid_index];
6145   if (name)
6146     tname = get_identifier (name);
6147
6148   TYPE_BUILT_IN (type) = 1;
6149
6150   if (tname)
6151     {
6152       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6153       set_identifier_type_value (tname, NULL_TREE);
6154       if ((int) rid_index < (int) CP_RID_MAX)
6155         /* Built-in types live in the global namespace. */
6156         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6157     }
6158   if (rname != NULL_TREE)
6159     {
6160       if (tname != NULL_TREE)
6161         {
6162           set_identifier_type_value (rname, NULL_TREE);
6163           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6164         }
6165       else
6166         {
6167           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6168           set_identifier_type_value (rname, NULL_TREE);
6169         }
6170     }
6171 }
6172
6173 /* Record one of the standard Java types.
6174  * Declare it as having the given NAME.
6175  * If SIZE > 0, it is the size of one of the integral types;
6176  * otherwise it is the negative of the size of one of the other types.  */
6177
6178 static tree
6179 record_builtin_java_type (name, size)
6180      const char *name;
6181      int size;
6182 {
6183   tree type, decl;
6184   if (size > 0)
6185     type = make_signed_type (size);
6186   else if (size > -32)
6187     { /* "__java_char" or ""__java_boolean". */
6188       type = make_unsigned_type (-size);
6189       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6190     }
6191   else
6192     { /* "__java_float" or ""__java_double". */
6193       type = make_node (REAL_TYPE);
6194       TYPE_PRECISION (type) = - size;
6195       layout_type (type);
6196     }
6197   record_builtin_type (CP_RID_MAX, name, type);
6198   decl = TYPE_NAME (type);
6199
6200   /* Suppress generate debug symbol entries for these types,
6201      since for normal C++ they are just clutter.
6202      However, push_lang_context undoes this if extern "Java" is seen. */
6203   DECL_IGNORED_P (decl) = 1;
6204
6205   TYPE_FOR_JAVA (type) = 1;
6206   return type;
6207 }
6208
6209 /* Push a type into the namespace so that the back-ends ignore it. */
6210
6211 static void
6212 record_unknown_type (type, name)
6213      tree type;
6214      const char *name;
6215 {
6216   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6217   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6218   DECL_IGNORED_P (decl) = 1;
6219   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6220   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6221   TYPE_ALIGN (type) = 1;
6222   TYPE_USER_ALIGN (type) = 0;
6223   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6224 }
6225
6226 /* An string for which we should create an IDENTIFIER_NODE at
6227    startup.  */
6228
6229 typedef struct predefined_identifier
6230 {
6231   /* The name of the identifier.  */
6232   const char *name;
6233   /* The place where the IDENTIFIER_NODE should be stored.  */
6234   tree *node;
6235   /* Non-zero if this is the name of a constructor or destructor.  */
6236   int ctor_or_dtor_p;
6237 } predefined_identifier;
6238
6239 /* Create all the predefined identifiers.  */
6240
6241 static void
6242 initialize_predefined_identifiers ()
6243 {
6244   struct predefined_identifier *pid;
6245
6246   /* A table of identifiers to create at startup.  */
6247   static predefined_identifier predefined_identifiers[] = {
6248     { "C++", &lang_name_cplusplus, 0 },
6249     { "C", &lang_name_c, 0 },
6250     { "Java", &lang_name_java, 0 },
6251     { CTOR_NAME, &ctor_identifier, 1 },
6252     { "__base_ctor", &base_ctor_identifier, 1 },
6253     { "__comp_ctor", &complete_ctor_identifier, 1 },
6254     { DTOR_NAME, &dtor_identifier, 1 },
6255     { "__comp_dtor", &complete_dtor_identifier, 1 },
6256     { "__base_dtor", &base_dtor_identifier, 1 },
6257     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6258     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6259     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6260     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6261     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6262     { "nelts", &nelts_identifier, 0 },
6263     { THIS_NAME, &this_identifier, 0 },
6264     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6265     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6266     { "_vptr", &vptr_identifier, 0 },
6267     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6268     { "__vtt_parm", &vtt_parm_identifier, 0 },
6269     { "std", &std_identifier, 0 },
6270     { NULL, NULL, 0 }
6271   };
6272
6273   for (pid = predefined_identifiers; pid->name; ++pid)
6274     {
6275       *pid->node = get_identifier (pid->name);
6276       if (pid->ctor_or_dtor_p)
6277         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6278     }
6279 }
6280
6281 /* Create the predefined scalar types of C,
6282    and some nodes representing standard constants (0, 1, (void *)0).
6283    Initialize the global binding level.
6284    Make definitions for built-in primitive functions.  */
6285
6286 void
6287 init_decl_processing ()
6288 {
6289   tree fields[20];
6290   int wchar_type_size;
6291   tree array_domain_type;
6292
6293   /* Check to see that the user did not specify an invalid combination
6294      of command-line options.  */
6295   if (flag_new_abi && !flag_vtable_thunks)
6296     fatal ("the new ABI requires vtable thunks");
6297
6298   /* Create all the identifiers we need.  */
6299   initialize_predefined_identifiers ();
6300
6301   /* Let the back-end now how to save and restore language-specific
6302      per-function globals.  */
6303   init_lang_status = &push_cp_function_context;
6304   free_lang_status = &pop_cp_function_context;
6305   mark_lang_status = &mark_cp_function_context;
6306
6307   cp_parse_init ();
6308   init_decl2 ();
6309   init_pt ();
6310
6311   /* Create the global variables.  */
6312   push_to_top_level ();
6313
6314   /* Enter the global namespace. */
6315   my_friendly_assert (global_namespace == NULL_TREE, 375);
6316   push_namespace (get_identifier ("::"));
6317   global_namespace = current_namespace;
6318   current_lang_name = NULL_TREE;
6319
6320   /* Adjust various flags based on command-line settings.  */
6321   if (flag_strict_prototype == 2)
6322     flag_strict_prototype = pedantic;
6323   if (! flag_permissive && ! pedantic)
6324     flag_pedantic_errors = 1;
6325   if (!flag_no_inline)
6326     flag_inline_trees = 1;
6327
6328   strict_prototypes_lang_c = flag_strict_prototype;
6329
6330   /* Initially, C.  */
6331   current_lang_name = lang_name_c;
6332
6333   current_function_decl = NULL_TREE;
6334   current_binding_level = NULL_BINDING_LEVEL;
6335   free_binding_level = NULL_BINDING_LEVEL;
6336
6337   /* Because most segmentation signals can be traced back into user
6338      code, catch them and at least give the user a chance of working
6339      around compiler bugs.  */
6340   signal (SIGSEGV, signal_catch);
6341
6342   /* We will also catch aborts in the back-end through signal_catch and
6343      give the user a chance to see where the error might be, and to defeat
6344      aborts in the back-end when there have been errors previously in their
6345      code.  */
6346 #ifdef SIGIOT
6347   signal (SIGIOT, signal_catch);
6348 #endif
6349 #ifdef SIGILL
6350   signal (SIGILL, signal_catch);
6351 #endif
6352 #ifdef SIGABRT
6353   signal (SIGABRT, signal_catch);
6354 #endif
6355 #ifdef SIGBUS
6356   signal (SIGBUS, signal_catch);
6357 #endif
6358
6359   build_common_tree_nodes (flag_signed_char);
6360
6361   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6362   TREE_TYPE (error_mark_list) = error_mark_node;
6363
6364   /* Make the binding_level structure for global names.  */
6365   pushlevel (0);
6366   global_binding_level = current_binding_level;
6367   /* The global level is the namespace level of ::.  */
6368   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6369   declare_namespace_level ();
6370
6371   /* Define `int' and `char' first so that dbx will output them first.  */
6372   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6373   record_builtin_type (RID_CHAR, "char", char_type_node);
6374
6375   /* `signed' is the same as `int' */
6376   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6377   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6378   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6379   record_builtin_type (CP_RID_MAX, "long unsigned int",
6380                        long_unsigned_type_node);
6381   record_builtin_type (CP_RID_MAX, "unsigned long", long_unsigned_type_node);
6382   record_builtin_type (CP_RID_MAX, "long long int",
6383                        long_long_integer_type_node);
6384   record_builtin_type (CP_RID_MAX, "long long unsigned int",
6385                        long_long_unsigned_type_node);
6386   record_builtin_type (CP_RID_MAX, "long long unsigned",
6387                        long_long_unsigned_type_node);
6388   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6389   record_builtin_type (CP_RID_MAX, "short unsigned int",
6390                        short_unsigned_type_node);
6391   record_builtin_type (CP_RID_MAX, "unsigned short",
6392                        short_unsigned_type_node);
6393
6394   ptrdiff_type_node
6395     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6396
6397   /* Define both `signed char' and `unsigned char'.  */
6398   record_builtin_type (CP_RID_MAX, "signed char", signed_char_type_node);
6399   record_builtin_type (CP_RID_MAX, "unsigned char", unsigned_char_type_node);
6400
6401   /* `unsigned long' is the standard type for sizeof.
6402      Note that stddef.h uses `unsigned long',
6403      and this must agree, even if long and int are the same size.  */
6404   set_sizetype
6405     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6406
6407   /* Create the widest literal types. */
6408   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6409   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6410                         widest_integer_literal_type_node));
6411
6412   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6413   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6414                         widest_unsigned_literal_type_node));
6415
6416   /* These are types that type_for_size and type_for_mode use.  */
6417   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6418   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6419   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6420   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6421 #if HOST_BITS_PER_WIDE_INT >= 64
6422   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6423 #endif
6424   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6425   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6426   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6427   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6428 #if HOST_BITS_PER_WIDE_INT >= 64
6429   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6430 #endif
6431
6432   build_common_tree_nodes_2 (flag_short_double);
6433
6434   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6435   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6436   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6437   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6438   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6439   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6440   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6441   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6442
6443   integer_two_node = build_int_2 (2, 0);
6444   TREE_TYPE (integer_two_node) = integer_type_node;
6445   integer_three_node = build_int_2 (3, 0);
6446   TREE_TYPE (integer_three_node) = integer_type_node;
6447
6448   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6449   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6450   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6451   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6452   TYPE_PRECISION (boolean_type_node) = 1;
6453   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6454   boolean_false_node = build_int_2 (0, 0);
6455   TREE_TYPE (boolean_false_node) = boolean_type_node;
6456   boolean_true_node = build_int_2 (1, 0);
6457   TREE_TYPE (boolean_true_node) = boolean_type_node;
6458
6459   signed_size_zero_node = build_int_2 (0, 0);
6460   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6461   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6462   record_builtin_type (CP_RID_MAX, "long double", long_double_type_node);
6463
6464   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6465                         complex_integer_type_node));
6466   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6467                         complex_float_type_node));
6468   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6469                         complex_double_type_node));
6470   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6471                         complex_long_double_type_node));
6472
6473   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6474
6475   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6476   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6477   TREE_PARMLIST (void_list_node) = 1;
6478
6479   /* Used for expressions that do nothing, but are not errors.  */
6480   void_zero_node = build_int_2 (0, 0);
6481   TREE_TYPE (void_zero_node) = void_type_node;
6482
6483   string_type_node = build_pointer_type (char_type_node);
6484   const_string_type_node
6485     = build_pointer_type (build_qualified_type (char_type_node,
6486                                                 TYPE_QUAL_CONST));
6487   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6488 #if 0
6489   record_builtin_type (CP_RID_MAX, NULL_PTR, string_type_node);
6490 #endif
6491
6492   /* Make a type to be the domain of a few array types
6493      whose domains don't really matter.
6494      200 is small enough that it always fits in size_t.  */
6495   array_domain_type = build_index_type (build_int_2 (200, 0));
6496
6497   /* Make a type for arrays of characters.
6498      With luck nothing will ever really depend on the length of this
6499      array type.  */
6500   char_array_type_node
6501     = build_array_type (char_type_node, array_domain_type);
6502
6503   /* Likewise for arrays of ints.  */
6504   int_array_type_node
6505     = build_array_type (integer_type_node, array_domain_type);
6506
6507   if (flag_new_abi)
6508     delta_type_node = ptrdiff_type_node;
6509   else if (flag_huge_objects)
6510     delta_type_node = long_integer_type_node;
6511   else
6512     delta_type_node = short_integer_type_node;
6513
6514   if (flag_new_abi)
6515     vtable_index_type = ptrdiff_type_node;
6516   else
6517     vtable_index_type = delta_type_node;
6518
6519   default_function_type
6520     = build_function_type (integer_type_node, NULL_TREE);
6521
6522   ptr_type_node = build_pointer_type (void_type_node);
6523   const_ptr_type_node
6524     = build_pointer_type (build_qualified_type (void_type_node,
6525                                                 TYPE_QUAL_CONST));
6526   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6527   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6528   lang_type_promotes_to = convert_type_from_ellipsis;
6529
6530   void_ftype_ptr
6531     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6532
6533   /* C++ extensions */
6534
6535   unknown_type_node = make_node (UNKNOWN_TYPE);
6536   record_unknown_type (unknown_type_node, "unknown type");
6537
6538   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6539   TREE_TYPE (unknown_type_node) = unknown_type_node;
6540
6541   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6542
6543   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6544      result.  */
6545   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6546   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6547
6548   /* This is special for C++ so functions can be overloaded.  */
6549   wchar_type_node = get_identifier (flag_short_wchar
6550                                     ? "short unsigned int"
6551                                     : WCHAR_TYPE);
6552   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6553   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6554   if (TREE_UNSIGNED (wchar_type_node))
6555     wchar_type_node = make_signed_type (wchar_type_size);
6556   else
6557     wchar_type_node = make_unsigned_type (wchar_type_size);
6558   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6559
6560   /* Artificial declaration of wchar_t -- can be bashed */
6561   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6562                                 wchar_type_node);
6563   pushdecl (wchar_decl_node);
6564
6565   /* This is for wide string constants.  */
6566   wchar_array_type_node
6567     = build_array_type (wchar_type_node, array_domain_type);
6568
6569   if (flag_vtable_thunks)
6570     {
6571       /* Make sure we get a unique function type, so we can give
6572          its pointer type a name.  (This wins for gdb.) */
6573       tree vfunc_type = make_node (FUNCTION_TYPE);
6574       TREE_TYPE (vfunc_type) = integer_type_node;
6575       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6576       layout_type (vfunc_type);
6577
6578       vtable_entry_type = build_pointer_type (vfunc_type);
6579     }
6580   else
6581     {
6582       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6583       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6584                               delta_type_node);
6585       fields[1] = build_decl (FIELD_DECL, index_identifier,
6586                               delta_type_node);
6587       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6588                               ptr_type_node);
6589       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6590                            double_type_node);
6591
6592       /* Make this part of an invisible union.  */
6593       fields[3] = copy_node (fields[2]);
6594       TREE_TYPE (fields[3]) = delta_type_node;
6595       DECL_NAME (fields[3]) = delta2_identifier;
6596       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6597       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6598       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6599       TREE_UNSIGNED (fields[3]) = 0;
6600       TREE_CHAIN (fields[2]) = fields[3];
6601       vtable_entry_type = build_qualified_type (vtable_entry_type,
6602                                                 TYPE_QUAL_CONST);
6603     }
6604   record_builtin_type (CP_RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6605
6606   vtbl_type_node
6607     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6608   layout_type (vtbl_type_node);
6609   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6610   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_type_node);
6611   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6612   layout_type (vtbl_ptr_type_node);
6613   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6614
6615   std_node = build_decl (NAMESPACE_DECL,
6616                          flag_honor_std
6617                          ? get_identifier ("fake std") : std_identifier,
6618                          void_type_node);
6619   pushdecl (std_node);
6620
6621   if (flag_new_abi)
6622     {
6623       push_namespace (get_identifier ("__cxxabiv1"));
6624       abi_node = current_namespace;
6625       pop_namespace ();
6626     }
6627
6628   global_type_node = make_node (LANG_TYPE);
6629   record_unknown_type (global_type_node, "global type");
6630
6631   /* Now, C++.  */
6632   current_lang_name = lang_name_cplusplus;
6633
6634   {
6635     tree bad_alloc_type_node, newtype, deltype;
6636     if (flag_honor_std)
6637       push_namespace (get_identifier ("std"));
6638     bad_alloc_type_node = xref_tag
6639       (class_type_node, get_identifier ("bad_alloc"), 1);
6640     if (flag_honor_std)
6641       pop_namespace ();
6642     newtype = build_exception_variant
6643       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6644     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6645     push_cp_library_fn (NEW_EXPR, newtype);
6646     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6647     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6648     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6649   }
6650
6651   abort_fndecl
6652     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6653
6654   /* Perform other language dependent initializations.  */
6655   init_class_processing ();
6656   init_init_processing ();
6657   init_search_processing ();
6658   init_rtti_processing ();
6659
6660   if (flag_exceptions)
6661     init_exception_processing ();
6662   if (flag_no_inline)
6663     {
6664       flag_inline_functions = 0;
6665     }
6666
6667   if (! supports_one_only ())
6668     flag_weak = 0;
6669
6670   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6671   make_fname_decl = cp_make_fname_decl;
6672   declare_function_name ();
6673
6674   /* Prepare to check format strings against argument lists.  */
6675   init_function_format_info ();
6676
6677   /* Show we use EH for cleanups.  */
6678   using_eh_for_cleanups ();
6679
6680   print_error_function = lang_print_error_function;
6681   valid_lang_attribute = cp_valid_lang_attribute;
6682
6683   /* Maintain consistency.  Perhaps we should just complain if they
6684      say -fwritable-strings?  */
6685   if (flag_writable_strings)
6686     flag_const_strings = 0;
6687
6688   /* Add GC roots for all of our global variables.  */
6689   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6690   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6691   ggc_add_tree_root (&integer_three_node, 1);
6692   ggc_add_tree_root (&integer_two_node, 1);
6693   ggc_add_tree_root (&signed_size_zero_node, 1);
6694   ggc_add_tree_root (&size_one_node, 1);
6695   ggc_add_tree_root (&size_zero_node, 1);
6696   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6697                 mark_binding_level);
6698   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6699   ggc_add_tree_root (&static_ctors, 1);
6700   ggc_add_tree_root (&static_dtors, 1);
6701   ggc_add_tree_root (&lastiddecl, 1);
6702
6703   ggc_add_tree_root (&last_function_parm_tags, 1);
6704   ggc_add_tree_root (&current_function_return_value, 1);
6705   ggc_add_tree_root (&current_function_parms, 1);
6706   ggc_add_tree_root (&current_function_parm_tags, 1);
6707   ggc_add_tree_root (&last_function_parms, 1);
6708   ggc_add_tree_root (&error_mark_list, 1);
6709
6710   ggc_add_tree_root (&global_namespace, 1);
6711   ggc_add_tree_root (&global_type_node, 1);
6712   ggc_add_tree_root (&anonymous_namespace_name, 1);
6713
6714   ggc_add_tree_root (&got_object, 1);
6715   ggc_add_tree_root (&got_scope, 1);
6716
6717   ggc_add_tree_root (&current_lang_name, 1);
6718   ggc_add_tree_root (&static_aggregates, 1);
6719 }
6720
6721 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6722    decl, NAME is the initialization string and TYPE_DEP indicates whether
6723    NAME depended on the type of the function. We make use of that to detect
6724    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6725    the function before emitting any of it, we don't need to treat the
6726    VAR_DECL specially. We can decide whether to emit it later, if it was
6727    used.  */
6728
6729 static tree
6730 cp_make_fname_decl (id, name, type_dep)
6731      tree id;
6732      const char *name;
6733      int type_dep;
6734 {
6735   tree decl, type, init;
6736   size_t length = strlen (name);
6737   tree domain = NULL_TREE;
6738
6739   if (!processing_template_decl)
6740     type_dep = 0;
6741   if (!type_dep)
6742     domain = build_index_type (build_int_2 (length, 0));
6743
6744   type =  build_cplus_array_type
6745           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6746            domain);
6747
6748   decl = build_decl (VAR_DECL, id, type);
6749   TREE_STATIC (decl) = 1;
6750   TREE_READONLY (decl) = 1;
6751   DECL_SOURCE_LINE (decl) = 0;
6752   DECL_ARTIFICIAL (decl) = 1;
6753   DECL_IN_SYSTEM_HEADER (decl) = 1;
6754   pushdecl (decl);
6755   if (processing_template_decl)
6756     decl = push_template_decl (decl);
6757   if (type_dep)
6758     {
6759       init = build (FUNCTION_NAME, type);
6760       DECL_PRETTY_FUNCTION_P (decl) = 1;
6761     }
6762   else
6763     {
6764       init = build_string (length + 1, name);
6765       TREE_TYPE (init) = type;
6766     }
6767   DECL_INITIAL (decl) = init;
6768   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6769
6770   /* We will have to make sure we only emit this, if it is actually used. */
6771   return decl;
6772 }
6773
6774 /* Function to print any language-specific context for an error message.  */
6775
6776 static void
6777 lang_print_error_function (file)
6778      const char *file;
6779 {
6780   default_print_error_function (file);
6781   maybe_print_template_context ();
6782 }
6783
6784 /* Entry point for the benefit of c_common_nodes_and_builtins.
6785
6786    Make a definition for a builtin function named NAME and whose data type
6787    is TYPE.  TYPE should be a function type with argument types.
6788
6789    CLASS and CODE tell later passes how to compile calls to this function.
6790    See tree.h for possible values.
6791
6792    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6793    the name to be called if we can't opencode the function.  */
6794
6795 tree
6796 builtin_function (name, type, code, class, libname)
6797      const char *name;
6798      tree type;
6799      int code;
6800      enum built_in_class class;
6801      const char *libname;
6802 {
6803   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6804   DECL_BUILT_IN_CLASS (decl) = class;
6805   DECL_FUNCTION_CODE (decl) = code;
6806
6807   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6808
6809   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6810      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6811      function in the namespace.  */
6812   pushdecl (decl);
6813   if (libname)
6814     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6815   make_function_rtl (decl);
6816
6817   /* Warn if a function in the namespace for users
6818      is used without an occasion to consider it declared.  */
6819   if (name[0] != '_' || name[1] != '_')
6820     DECL_ANTICIPATED (decl) = 1;
6821
6822   return decl;
6823 }
6824
6825 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6826    function.  Not called directly.  */
6827
6828 static tree
6829 build_library_fn_1 (name, operator_code, type)
6830      tree name;
6831      enum tree_code operator_code;
6832      tree type;
6833 {
6834   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6835   DECL_EXTERNAL (fn) = 1;
6836   TREE_PUBLIC (fn) = 1;
6837   DECL_ARTIFICIAL (fn) = 1;
6838   TREE_NOTHROW (fn) = 1;
6839   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6840   return fn;
6841 }
6842
6843 /* Returns the _DECL for a library function with C linkage.
6844    We assume that such functions never throw; if this is incorrect,
6845    callers should unset TREE_NOTHROW.  */
6846
6847 tree
6848 build_library_fn (name, type)
6849      tree name;
6850      tree type;
6851 {
6852   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6853   make_function_rtl (fn);
6854   return fn;
6855 }
6856
6857 /* Returns the _DECL for a library function with C++ linkage.  */
6858
6859 static tree
6860 build_cp_library_fn (name, operator_code, type)
6861      tree name;
6862      enum tree_code operator_code;
6863      tree type;
6864 {
6865   tree fn = build_library_fn_1 (name, operator_code, type);
6866   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6867   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6868   set_mangled_name_for_decl (fn);
6869   make_function_rtl (fn);
6870   return fn;
6871 }
6872
6873 /* Like build_library_fn, but takes a C string instead of an
6874    IDENTIFIER_NODE.  */
6875
6876 tree
6877 build_library_fn_ptr (name, type)
6878      const char *name;
6879      tree type;
6880 {
6881   return build_library_fn (get_identifier (name), type);
6882 }
6883
6884 /* Like build_cp_library_fn, but takes a C string instead of an
6885    IDENTIFIER_NODE.  */
6886
6887 tree
6888 build_cp_library_fn_ptr (name, type)
6889      const char *name;
6890      tree type;
6891 {
6892   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6893 }
6894
6895 /* Like build_library_fn, but also pushes the function so that we will
6896    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6897
6898 tree
6899 push_library_fn (name, type)
6900      tree name, type;
6901 {
6902   tree fn = build_library_fn (name, type);
6903   pushdecl_top_level (fn);
6904   return fn;
6905 }
6906
6907 /* Like build_cp_library_fn, but also pushes the function so that it
6908    will be found by normal lookup.  */
6909
6910 static tree
6911 push_cp_library_fn (operator_code, type)
6912      enum tree_code operator_code;
6913      tree type;
6914 {
6915   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6916                                  operator_code,
6917                                  type);
6918   pushdecl (fn);
6919   return fn;
6920 }
6921
6922 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6923    a FUNCTION_TYPE.  */
6924
6925 tree
6926 push_void_library_fn (name, parmtypes)
6927      tree name, parmtypes;
6928 {
6929   tree type = build_function_type (void_type_node, parmtypes);
6930   return push_library_fn (name, type);
6931 }
6932
6933 /* Like push_library_fn, but also note that this function throws
6934    and does not return.  Used for __throw_foo and the like.  */
6935
6936 tree
6937 push_throw_library_fn (name, type)
6938      tree name, type;
6939 {
6940   tree fn = push_library_fn (name, type);
6941   TREE_THIS_VOLATILE (fn) = 1;
6942   TREE_NOTHROW (fn) = 0;
6943   return fn;
6944 }
6945 \f
6946 /* When we call finish_struct for an anonymous union, we create
6947    default copy constructors and such.  But, an anonymous union
6948    shouldn't have such things; this function undoes the damage to the
6949    anonymous union type T.
6950
6951    (The reason that we create the synthesized methods is that we don't
6952    distinguish `union { int i; }' from `typedef union { int i; } U'.
6953    The first is an anonymous union; the second is just an ordinary
6954    union type.)  */
6955
6956 void
6957 fixup_anonymous_aggr (t)
6958      tree t;
6959 {
6960   tree *q;
6961
6962   /* Wipe out memory of synthesized methods */
6963   TYPE_HAS_CONSTRUCTOR (t) = 0;
6964   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6965   TYPE_HAS_INIT_REF (t) = 0;
6966   TYPE_HAS_CONST_INIT_REF (t) = 0;
6967   TYPE_HAS_ASSIGN_REF (t) = 0;
6968   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6969
6970   /* Splice the implicitly generated functions out of the TYPE_METHODS
6971      list.  */
6972   q = &TYPE_METHODS (t);
6973   while (*q)
6974     {
6975       if (DECL_ARTIFICIAL (*q))
6976         *q = TREE_CHAIN (*q);
6977       else
6978         q = &TREE_CHAIN (*q);
6979     }
6980
6981   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6982   if (TYPE_METHODS (t))
6983     error ("an anonymous union cannot have function members");
6984 }
6985
6986 /* Make sure that a declaration with no declarator is well-formed, i.e.
6987    just defines a tagged type or anonymous union.
6988
6989    Returns the type defined, if any.  */
6990
6991 tree
6992 check_tag_decl (declspecs)
6993      tree declspecs;
6994 {
6995   int found_type = 0;
6996   int saw_friend = 0;
6997   tree ob_modifier = NULL_TREE;
6998   register tree link;
6999   register tree t = NULL_TREE;
7000
7001   for (link = declspecs; link; link = TREE_CHAIN (link))
7002     {
7003       register tree value = TREE_VALUE (link);
7004
7005       if (TYPE_P (value)
7006           || (TREE_CODE (value) == IDENTIFIER_NODE
7007               && IDENTIFIER_GLOBAL_VALUE (value)
7008               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
7009         {
7010           ++found_type;
7011
7012           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
7013             {
7014               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7015               t = value;
7016             }
7017         }
7018       else if (value == ridpointers[(int) RID_FRIEND])
7019         {
7020           if (current_class_type == NULL_TREE
7021               || current_scope () != current_class_type)
7022             ob_modifier = value;
7023           else
7024             saw_friend = 1;
7025         }
7026       else if (value == ridpointers[(int) RID_STATIC]
7027                || value == ridpointers[(int) RID_EXTERN]
7028                || value == ridpointers[(int) RID_AUTO]
7029                || value == ridpointers[(int) RID_REGISTER]
7030                || value == ridpointers[(int) RID_INLINE]
7031                || value == ridpointers[(int) RID_VIRTUAL]
7032                || value == ridpointers[(int) RID_CONST]
7033                || value == ridpointers[(int) RID_VOLATILE]
7034                || value == ridpointers[(int) RID_EXPLICIT])
7035         ob_modifier = value;
7036     }
7037
7038   if (found_type > 1)
7039     error ("multiple types in one declaration");
7040
7041   if (t == NULL_TREE && ! saw_friend)
7042     pedwarn ("declaration does not declare anything");
7043
7044   /* Check for an anonymous union.  We're careful
7045      accessing TYPE_IDENTIFIER because some built-in types, like
7046      pointer-to-member types, do not have TYPE_NAME.  */
7047   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7048            && TYPE_NAME (t)
7049            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7050     {
7051       /* Anonymous unions are objects, so they can have specifiers.  */;
7052       SET_ANON_AGGR_TYPE_P (t);
7053
7054       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7055         pedwarn ("ISO C++ prohibits anonymous structs");
7056     }
7057
7058   else if (ob_modifier)
7059     {
7060       if (ob_modifier == ridpointers[(int) RID_INLINE]
7061           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7062         cp_error ("`%D' can only be specified for functions", ob_modifier);
7063       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7064         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7065       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7066         cp_error ("`%D' can only be specified for constructors",
7067                   ob_modifier);
7068       else
7069         cp_error ("`%D' can only be specified for objects and functions",
7070                   ob_modifier);
7071     }
7072
7073   return t;
7074 }
7075
7076 /* Called when a declaration is seen that contains no names to declare.
7077    If its type is a reference to a structure, union or enum inherited
7078    from a containing scope, shadow that tag name for the current scope
7079    with a forward reference.
7080    If its type defines a new named structure or union
7081    or defines an enum, it is valid but we need not do anything here.
7082    Otherwise, it is an error.
7083
7084    C++: may have to grok the declspecs to learn about static,
7085    complain for anonymous unions.  */
7086
7087 void
7088 shadow_tag (declspecs)
7089      tree declspecs;
7090 {
7091   tree t = check_tag_decl (declspecs);
7092
7093   if (t)
7094     maybe_process_partial_specialization (t);
7095
7096   /* This is where the variables in an anonymous union are
7097      declared.  An anonymous union declaration looks like:
7098      union { ... } ;
7099      because there is no declarator after the union, the parser
7100      sends that declaration here.  */
7101   if (t && ANON_AGGR_TYPE_P (t))
7102     {
7103       fixup_anonymous_aggr (t);
7104
7105       if (TYPE_FIELDS (t))
7106         {
7107           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7108                                       NULL_TREE);
7109           finish_anon_union (decl);
7110         }
7111     }
7112 }
7113 \f
7114 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7115
7116 tree
7117 groktypename (typename)
7118      tree typename;
7119 {
7120   if (TREE_CODE (typename) != TREE_LIST)
7121     return typename;
7122   return grokdeclarator (TREE_VALUE (typename),
7123                          TREE_PURPOSE (typename),
7124                          TYPENAME, 0, NULL_TREE);
7125 }
7126
7127 /* Decode a declarator in an ordinary declaration or data definition.
7128    This is called as soon as the type information and variable name
7129    have been parsed, before parsing the initializer if any.
7130    Here we create the ..._DECL node, fill in its type,
7131    and put it on the list of decls for the current context.
7132    The ..._DECL node is returned as the value.
7133
7134    Exception: for arrays where the length is not specified,
7135    the type is left null, to be filled in by `cp_finish_decl'.
7136
7137    Function definitions do not come here; they go to start_function
7138    instead.  However, external and forward declarations of functions
7139    do go through here.  Structure field declarations are done by
7140    grokfield and not through here.  */
7141
7142 tree
7143 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7144      tree declarator, declspecs;
7145      int initialized;
7146      tree attributes, prefix_attributes;
7147 {
7148   register tree decl;
7149   register tree type, tem;
7150   tree context;
7151   extern int have_extern_spec;
7152   extern int used_extern_spec;
7153   tree attrlist;
7154
7155 #if 0
7156   /* See code below that used this.  */
7157   int init_written = initialized;
7158 #endif
7159
7160   /* This should only be done once on the top most decl.  */
7161   if (have_extern_spec && !used_extern_spec)
7162     {
7163       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7164                                   declspecs);
7165       used_extern_spec = 1;
7166     }
7167
7168   if (attributes || prefix_attributes)
7169     attrlist = build_tree_list (attributes, prefix_attributes);
7170   else
7171     attrlist = NULL_TREE;
7172
7173   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7174                          attrlist);
7175
7176   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7177     return NULL_TREE;
7178
7179   type = TREE_TYPE (decl);
7180
7181   if (type == error_mark_node)
7182     return NULL_TREE;
7183
7184   context = DECL_CONTEXT (decl);
7185
7186   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7187       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7188     {
7189       /* When parsing the initializer, lookup should use the object's
7190          namespace. */
7191       push_decl_namespace (context);
7192     }
7193
7194   /* We are only interested in class contexts, later. */
7195   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7196     context = NULL_TREE;
7197
7198   if (initialized)
7199     /* Is it valid for this decl to have an initializer at all?
7200        If not, set INITIALIZED to zero, which will indirectly
7201        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7202     switch (TREE_CODE (decl))
7203       {
7204       case TYPE_DECL:
7205         /* typedef foo = bar  means give foo the same type as bar.
7206            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7207            Any other case of an initialization in a TYPE_DECL is an error.  */
7208         if (pedantic || list_length (declspecs) > 1)
7209           {
7210             cp_error ("typedef `%D' is initialized", decl);
7211             initialized = 0;
7212           }
7213         break;
7214
7215       case FUNCTION_DECL:
7216         cp_error ("function `%#D' is initialized like a variable", decl);
7217         initialized = 0;
7218         break;
7219
7220       default:
7221         break;
7222       }
7223
7224   if (initialized)
7225     {
7226       if (! toplevel_bindings_p ()
7227           && DECL_EXTERNAL (decl))
7228         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7229                     decl);
7230       DECL_EXTERNAL (decl) = 0;
7231       if (toplevel_bindings_p ())
7232         TREE_STATIC (decl) = 1;
7233
7234       /* Tell `pushdecl' this is an initialized decl
7235          even though we don't yet have the initializer expression.
7236          Also tell `cp_finish_decl' it may store the real initializer.  */
7237       DECL_INITIAL (decl) = error_mark_node;
7238     }
7239
7240 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7241   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7242 #endif
7243
7244   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7245   cplus_decl_attributes (decl, attributes, prefix_attributes);
7246
7247   if (context && COMPLETE_TYPE_P (complete_type (context)))
7248     {
7249       push_nested_class (context, 2);
7250
7251       if (TREE_CODE (decl) == VAR_DECL)
7252         {
7253           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7254           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7255             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7256           else
7257             {
7258               if (DECL_CONTEXT (field) != context)
7259                 {
7260                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7261                               DECL_CONTEXT (field), DECL_NAME (decl),
7262                               context, DECL_NAME (decl));
7263                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7264                 }
7265               /* Static data member are tricky; an in-class initialization
7266                  still doesn't provide a definition, so the in-class
7267                  declaration will have DECL_EXTERNAL set, but will have an
7268                  initialization.  Thus, duplicate_decls won't warn
7269                  about this situation, and so we check here.  */
7270               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7271                 cp_error ("duplicate initialization of %D", decl);
7272               if (duplicate_decls (decl, field))
7273                 decl = field;
7274             }
7275         }
7276       else
7277         {
7278           tree field = check_classfn (context, decl);
7279           if (field && duplicate_decls (decl, field))
7280             decl = field;
7281         }
7282
7283       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7284       DECL_IN_AGGR_P (decl) = 0;
7285       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7286           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7287         {
7288           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7289           /* [temp.expl.spec] An explicit specialization of a static data
7290              member of a template is a definition if the declaration
7291              includes an initializer; otherwise, it is a declaration.
7292
7293              We check for processing_specialization so this only applies
7294              to the new specialization syntax.  */
7295           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7296             DECL_EXTERNAL (decl) = 1;
7297         }
7298
7299       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7300         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7301                     decl);
7302     }
7303
7304   /* Enter this declaration into the symbol table.  */
7305   tem = maybe_push_decl (decl);
7306
7307   if (processing_template_decl)
7308     tem = push_template_decl (tem);
7309
7310 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7311   /* Tell the back-end to use or not use .common as appropriate.  If we say
7312      -fconserve-space, we want this to save .data space, at the expense of
7313      wrong semantics.  If we say -fno-conserve-space, we want this to
7314      produce errors about redefs; to do this we force variables into the
7315      data segment.  */
7316   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7317 #endif
7318
7319   if (! processing_template_decl)
7320     start_decl_1 (tem);
7321
7322   return tem;
7323 }
7324
7325 void
7326 start_decl_1 (decl)
7327      tree decl;
7328 {
7329   tree type = TREE_TYPE (decl);
7330   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7331
7332   if (type == error_mark_node)
7333     return;
7334
7335   /* If this type of object needs a cleanup, but we're not allowed to
7336      add any more objects with cleanups to the current scope, create a
7337      new binding level.  */
7338   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7339       && current_binding_level->more_cleanups_ok == 0)
7340     {
7341       keep_next_level (2);
7342       pushlevel (1);
7343       clear_last_expr ();
7344       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7345     }
7346
7347   if (initialized)
7348     /* Is it valid for this decl to have an initializer at all?
7349        If not, set INITIALIZED to zero, which will indirectly
7350        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7351     {
7352       /* Don't allow initializations for incomplete types except for
7353          arrays which might be completed by the initialization.  */
7354       if (COMPLETE_TYPE_P (complete_type (type)))
7355         ;                       /* A complete type is ok.  */
7356       else if (TREE_CODE (type) != ARRAY_TYPE)
7357         {
7358           cp_error ("variable `%#D' has initializer but incomplete type",
7359                     decl);
7360           initialized = 0;
7361           type = TREE_TYPE (decl) = error_mark_node;
7362         }
7363       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7364         {
7365           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7366             cp_error ("elements of array `%#D' have incomplete type", decl);
7367           /* else we already gave an error in start_decl.  */
7368           initialized = 0;
7369         }
7370     }
7371
7372   if (!initialized
7373       && TREE_CODE (decl) != TYPE_DECL
7374       && TREE_CODE (decl) != TEMPLATE_DECL
7375       && type != error_mark_node
7376       && IS_AGGR_TYPE (type)
7377       && ! DECL_EXTERNAL (decl))
7378     {
7379       if ((! processing_template_decl || ! uses_template_parms (type))
7380           && !COMPLETE_TYPE_P (complete_type (type)))
7381         {
7382           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7383                  decl);
7384           /* Change the type so that assemble_variable will give
7385              DECL an rtl we can live with: (mem (const_int 0)).  */
7386           type = TREE_TYPE (decl) = error_mark_node;
7387         }
7388       else
7389         {
7390           /* If any base type in the hierarchy of TYPE needs a constructor,
7391              then we set initialized to 1.  This way any nodes which are
7392              created for the purposes of initializing this aggregate
7393              will live as long as it does.  This is necessary for global
7394              aggregates which do not have their initializers processed until
7395              the end of the file.  */
7396           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7397         }
7398     }
7399
7400   if (! initialized)
7401     DECL_INITIAL (decl) = NULL_TREE;
7402 }
7403
7404 /* Handle initialization of references.
7405    These three arguments are from `cp_finish_decl', and have the
7406    same meaning here that they do there.
7407
7408    Quotes on semantics can be found in ARM 8.4.3.  */
7409
7410 static void
7411 grok_reference_init (decl, type, init)
7412      tree decl, type, init;
7413 {
7414   tree tmp;
7415
7416   if (init == NULL_TREE)
7417     {
7418       if ((DECL_LANG_SPECIFIC (decl) == 0
7419            || DECL_IN_AGGR_P (decl) == 0)
7420           && ! DECL_THIS_EXTERN (decl))
7421         cp_error ("`%D' declared as reference but not initialized", decl);
7422       return;
7423     }
7424
7425   if (init == error_mark_node)
7426     return;
7427
7428   if (TREE_CODE (init) == CONSTRUCTOR)
7429     {
7430       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7431       return;
7432     }
7433
7434   if (TREE_CODE (init) == TREE_LIST)
7435     init = build_compound_expr (init);
7436
7437   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7438     init = convert_from_reference (init);
7439
7440   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7441       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7442     {
7443       /* Note: default conversion is only called in very special cases.  */
7444       init = default_conversion (init);
7445     }
7446
7447   /* Convert INIT to the reference type TYPE.  This may involve the
7448      creation of a temporary, whose lifetime must be the same as that
7449      of the reference.  If so, a DECL_STMT for the temporary will be
7450      added just after the DECL_STMT for DECL.  That's why we don't set
7451      DECL_INITIAL for local references (instead assigning to them
7452      explicitly); we need to allow the temporary to be initialized
7453      first.  */
7454   tmp = convert_to_reference
7455     (type, init, CONV_IMPLICIT,
7456      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7457      decl);
7458
7459   if (tmp == error_mark_node)
7460     return;
7461   else if (tmp != NULL_TREE)
7462     {
7463       init = tmp;
7464       tmp = save_expr (tmp);
7465       if (building_stmt_tree ())
7466         {
7467           /* Initialize the declaration.  */
7468           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7469           finish_expr_stmt (tmp);
7470         }
7471       else
7472         DECL_INITIAL (decl) = tmp;
7473     }
7474   else
7475     {
7476       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7477       return;
7478     }
7479
7480   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7481     {
7482       expand_static_init (decl, DECL_INITIAL (decl));
7483       DECL_INITIAL (decl) = NULL_TREE;
7484     }
7485   return;
7486 }
7487
7488 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7489    mucking with forces it does not comprehend (i.e. initialization with a
7490    constructor).  If we are at global scope and won't go into COMMON, fill
7491    it in with a dummy CONSTRUCTOR to force the variable into .data;
7492    otherwise we can use error_mark_node.  */
7493
7494 static tree
7495 obscure_complex_init (decl, init)
7496      tree decl, init;
7497 {
7498   if (! flag_no_inline && TREE_STATIC (decl))
7499     {
7500       if (extract_init (decl, init))
7501         return NULL_TREE;
7502     }
7503
7504 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7505   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7506     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7507                                  NULL_TREE);
7508   else
7509 #endif
7510     DECL_INITIAL (decl) = error_mark_node;
7511
7512   return init;
7513 }
7514
7515 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7516    array until we finish parsing the initializer.  If that's the
7517    situation we're in, update DECL accordingly.  */
7518
7519 static void
7520 maybe_deduce_size_from_array_init (decl, init)
7521      tree decl;
7522      tree init;
7523 {
7524   tree type = TREE_TYPE (decl);
7525
7526   if (TREE_CODE (type) == ARRAY_TYPE
7527       && TYPE_DOMAIN (type) == NULL_TREE
7528       && TREE_CODE (decl) != TYPE_DECL)
7529     {
7530       int do_default
7531         = (TREE_STATIC (decl)
7532            /* Even if pedantic, an external linkage array
7533               may have incomplete type at first.  */
7534            ? pedantic && ! DECL_EXTERNAL (decl)
7535            : !DECL_EXTERNAL (decl));
7536       tree initializer = init ? init : DECL_INITIAL (decl);
7537       int failure = complete_array_type (type, initializer, do_default);
7538
7539       if (failure == 1)
7540         cp_error ("initializer fails to determine size of `%D'", decl);
7541
7542       if (failure == 2)
7543         {
7544           if (do_default)
7545             cp_error ("array size missing in `%D'", decl);
7546           /* If a `static' var's size isn't known, make it extern as
7547              well as static, so it does not get allocated.  If it's not
7548              `static', then don't mark it extern; finish_incomplete_decl
7549              will give it a default size and it will get allocated.  */
7550           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7551             DECL_EXTERNAL (decl) = 1;
7552         }
7553
7554       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7555           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7556                               integer_zero_node))
7557         cp_error ("zero-size array `%D'", decl);
7558
7559       layout_decl (decl, 0);
7560     }
7561 }
7562
7563 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7564    any appropriate error messages regarding the layout.  */
7565
7566 static void
7567 layout_var_decl (decl)
7568      tree decl;
7569 {
7570   tree type = TREE_TYPE (decl);
7571 #if 0
7572   tree ttype = target_type (type);
7573 #endif
7574
7575   /* If we haven't already layed out this declaration, do so now.
7576      Note that we must not call complete type for an external object
7577      because it's type might involve templates that we are not
7578      supposed to isntantiate yet.  (And it's perfectly legal to say
7579      `extern X x' for some incomplete type `X'.)  */
7580   if (!DECL_EXTERNAL (decl))
7581     complete_type (type);
7582   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7583     layout_decl (decl, 0);
7584
7585   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7586     {
7587       /* An automatic variable with an incomplete type: that is an error.
7588          Don't talk about array types here, since we took care of that
7589          message in grokdeclarator.  */
7590       cp_error ("storage size of `%D' isn't known", decl);
7591       TREE_TYPE (decl) = error_mark_node;
7592     }
7593 #if 0
7594   /* Keep this code around in case we later want to control debug info
7595      based on whether a type is "used".  (jason 1999-11-11) */
7596
7597   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7598     /* Let debugger know it should output info for this type.  */
7599     note_debug_info_needed (ttype);
7600
7601   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7602     note_debug_info_needed (DECL_CONTEXT (decl));
7603 #endif
7604
7605   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7606       && DECL_SIZE (decl) != NULL_TREE
7607       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7608     {
7609       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7610         constant_expression_warning (DECL_SIZE (decl));
7611       else
7612         cp_error ("storage size of `%D' isn't constant", decl);
7613     }
7614 }
7615
7616 /* If a local static variable is declared in an inline function, or if
7617    we have a weak definition, we must endeavor to create only one
7618    instance of the variable at link-time.  */
7619
7620 static void
7621 maybe_commonize_var (decl)
7622      tree decl;
7623 {
7624   /* Static data in a function with comdat linkage also has comdat
7625      linkage.  */
7626   if (TREE_STATIC (decl)
7627       /* Don't mess with __FUNCTION__.  */
7628       && ! DECL_ARTIFICIAL (decl)
7629       && current_function_decl
7630       && DECL_CONTEXT (decl) == current_function_decl
7631       && (DECL_THIS_INLINE (current_function_decl)
7632           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7633       && TREE_PUBLIC (current_function_decl))
7634     {
7635       /* Rather than try to get this right with inlining, we suppress
7636          inlining of such functions.  */
7637       current_function_cannot_inline
7638         = "function with static variable cannot be inline";
7639
7640       /* If flag_weak, we don't need to mess with this, as we can just
7641          make the function weak, and let it refer to its unique local
7642          copy.  This works because we don't allow the function to be
7643          inlined.  */
7644       if (! flag_weak)
7645         {
7646           if (DECL_INTERFACE_KNOWN (current_function_decl))
7647             {
7648               TREE_PUBLIC (decl) = 1;
7649               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7650             }
7651           else if (DECL_INITIAL (decl) == NULL_TREE
7652                    || DECL_INITIAL (decl) == error_mark_node)
7653             {
7654               TREE_PUBLIC (decl) = 1;
7655               DECL_COMMON (decl) = 1;
7656             }
7657           /* else we lose. We can only do this if we can use common,
7658              which we can't if it has been initialized.  */
7659
7660           if (TREE_PUBLIC (decl))
7661             DECL_ASSEMBLER_NAME (decl)
7662               = build_static_name (current_function_decl, DECL_NAME (decl));
7663           else
7664             {
7665               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7666               cp_warning_at ("  you can work around this by removing the initializer", decl);
7667             }
7668         }
7669     }
7670   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7671     /* Set it up again; we might have set DECL_INITIAL since the last
7672        time.  */
7673     comdat_linkage (decl);
7674 }
7675
7676 /* Issue an error message if DECL is an uninitialized const variable.  */
7677
7678 static void
7679 check_for_uninitialized_const_var (decl)
7680      tree decl;
7681 {
7682   tree type = TREE_TYPE (decl);
7683
7684   /* ``Unless explicitly declared extern, a const object does not have
7685      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7686      7.1.6 */
7687   if (TREE_CODE (decl) == VAR_DECL
7688       && TREE_CODE (type) != REFERENCE_TYPE
7689       && CP_TYPE_CONST_P (type)
7690       && !TYPE_NEEDS_CONSTRUCTING (type)
7691       && !DECL_INITIAL (decl))
7692     cp_error ("uninitialized const `%D'", decl);
7693 }
7694
7695 /* Verify INIT (the initializer for DECL), and record the
7696    initialization in DECL_INITIAL, if appropriate.  Returns a new
7697    value for INIT.  */
7698
7699 static tree
7700 check_initializer (decl, init)
7701      tree decl;
7702      tree init;
7703 {
7704   tree type;
7705
7706   if (TREE_CODE (decl) == FIELD_DECL)
7707     return init;
7708
7709   type = TREE_TYPE (decl);
7710
7711   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7712   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7713     init = NULL_TREE;
7714
7715   /* Check the initializer.  */
7716   if (init)
7717     {
7718       /* Things that are going to be initialized need to have complete
7719          type.  */
7720       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7721
7722       if (type == error_mark_node)
7723         /* We will have already complained.  */
7724         init = NULL_TREE;
7725       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7726         {
7727           cp_error ("variable-sized object `%D' may not be initialized", decl);
7728           init = NULL_TREE;
7729         }
7730       else if (TREE_CODE (type) == ARRAY_TYPE
7731                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7732         {
7733           cp_error ("elements of array `%#D' have incomplete type", decl);
7734           init = NULL_TREE;
7735         }
7736       else if (!COMPLETE_TYPE_P (type))
7737         {
7738           cp_error ("`%D' has incomplete type", decl);
7739           TREE_TYPE (decl) = error_mark_node;
7740           init = NULL_TREE;
7741         }
7742     }
7743
7744   if (TREE_CODE (decl) == CONST_DECL)
7745     {
7746       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7747
7748       DECL_INITIAL (decl) = init;
7749
7750       /* This will keep us from needing to worry about our obstacks.  */
7751       my_friendly_assert (init != NULL_TREE, 149);
7752       init = NULL_TREE;
7753     }
7754   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7755     {
7756       if (TREE_STATIC (decl))
7757         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7758       grok_reference_init (decl, type, init);
7759       init = NULL_TREE;
7760     }
7761   else if (init)
7762     {
7763       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7764         {
7765           if (TREE_CODE (type) == ARRAY_TYPE)
7766             init = digest_init (type, init, (tree *) 0);
7767           else if (TREE_CODE (init) == CONSTRUCTOR
7768                    && TREE_HAS_CONSTRUCTOR (init))
7769             {
7770               if (TYPE_NON_AGGREGATE_CLASS (type))
7771                 {
7772                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7773                             decl);
7774                   init = error_mark_node;
7775                 }
7776               else
7777                 goto dont_use_constructor;
7778             }
7779         }
7780       else
7781         {
7782         dont_use_constructor:
7783           if (TREE_CODE (init) != TREE_VEC)
7784             init = store_init_value (decl, init);
7785         }
7786
7787       if (init)
7788         /* We must hide the initializer so that expand_decl
7789            won't try to do something it does not understand.  */
7790         init = obscure_complex_init (decl, init);
7791     }
7792   else if (DECL_EXTERNAL (decl))
7793     ;
7794   else if (TYPE_P (type)
7795            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7796     {
7797       tree core_type = strip_array_types (type);
7798
7799       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7800         {
7801           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7802             cp_error ("structure `%D' with uninitialized const members", decl);
7803           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7804             cp_error ("structure `%D' with uninitialized reference members",
7805                       decl);
7806         }
7807
7808       check_for_uninitialized_const_var (decl);
7809
7810       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7811         init = obscure_complex_init (decl, NULL_TREE);
7812
7813     }
7814   else
7815     check_for_uninitialized_const_var (decl);
7816
7817   return init;
7818 }
7819
7820 /* If DECL is not a local variable, give it RTL.  */
7821
7822 static void
7823 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7824      tree decl;
7825      tree init;
7826      const char *asmspec;
7827 {
7828   int toplev;
7829   tree type;
7830
7831   type = TREE_TYPE (decl);
7832   toplev = toplevel_bindings_p ();
7833
7834   /* Handle non-variables up front.  */
7835   if (TREE_CODE (decl) != VAR_DECL)
7836     {
7837       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7838       return;
7839     }
7840
7841   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7842   if (asmspec)
7843     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7844
7845   if (DECL_VIRTUAL_P (decl))
7846     make_decl_rtl (decl, NULL_PTR, toplev);
7847   else if (TREE_READONLY (decl)
7848            && DECL_INITIAL (decl) != NULL_TREE
7849            && DECL_INITIAL (decl) != error_mark_node
7850            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7851     {
7852       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7853
7854       if (toplev && ! TREE_PUBLIC (decl))
7855         {
7856           /* If this is a static const, change its apparent linkage
7857              if it belongs to a #pragma interface.  */
7858           if (!interface_unknown)
7859             {
7860               TREE_PUBLIC (decl) = 1;
7861               DECL_EXTERNAL (decl) = interface_only;
7862             }
7863           make_decl_rtl (decl, asmspec, toplev);
7864         }
7865       else if (toplev)
7866         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7867     }
7868   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7869     {
7870       my_friendly_assert (TREE_STATIC (decl), 19990828);
7871
7872       if (init == NULL_TREE
7873 #ifdef DEFAULT_STATIC_DEFS
7874           /* If this code is dead, then users must
7875              explicitly declare static member variables
7876              outside the class def'n as well.  */
7877           && TYPE_NEEDS_CONSTRUCTING (type)
7878 #endif
7879           )
7880         {
7881           DECL_EXTERNAL (decl) = 1;
7882           make_decl_rtl (decl, asmspec, 1);
7883         }
7884       else
7885         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7886     }
7887   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7888            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7889     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7890 }
7891
7892 /* The old ARM scoping rules injected variables declared in the
7893    initialization statement of a for-statement into the surrounding
7894    scope.  We support this usage, in order to be backward-compatible.
7895    DECL is a just-declared VAR_DECL; if necessary inject its
7896    declaration into the surrounding scope.  */
7897
7898 void
7899 maybe_inject_for_scope_var (decl)
7900      tree decl;
7901 {
7902   if (current_binding_level->is_for_scope)
7903     {
7904       struct binding_level *outer
7905         = current_binding_level->level_chain;
7906
7907       /* Check to see if the same name is already bound at the outer
7908          level, either because it was directly declared, or because a
7909          dead for-decl got preserved.  In either case, the code would
7910          not have been valid under the ARM scope rules, so clear
7911          is_for_scope for the current_binding_level.
7912
7913          Otherwise, we need to preserve the temp slot for decl to last
7914          into the outer binding level.  */
7915
7916       tree outer_binding
7917         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7918
7919       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7920           && (TREE_CODE (BINDING_VALUE (outer_binding))
7921               == VAR_DECL)
7922           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7923         {
7924           BINDING_VALUE (outer_binding)
7925             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7926           current_binding_level->is_for_scope = 0;
7927         }
7928       else if (DECL_IN_MEMORY_P (decl))
7929         preserve_temp_slots (DECL_RTL (decl));
7930     }
7931 }
7932
7933 /* Generate code to initialize DECL (a local variable).  */
7934
7935 void
7936 initialize_local_var (decl, init, flags)
7937      tree decl;
7938      tree init;
7939      int flags;
7940 {
7941   tree type = TREE_TYPE (decl);
7942
7943   /* If the type is bogus, don't bother initializing the variable.  */
7944   if (type == error_mark_node)
7945     return;
7946
7947   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7948     {
7949       /* If we used it already as memory, it must stay in memory.  */
7950       DECL_INITIAL (decl) = NULL_TREE;
7951       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7952     }
7953
7954   /* Local statics are handled differently from ordinary automatic
7955      variables.  */
7956   if (TREE_STATIC (decl))
7957     {
7958       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7959           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7960         expand_static_init (decl, init);
7961       return;
7962     }
7963
7964   if (DECL_SIZE (decl) && type != error_mark_node)
7965     {
7966       int already_used;
7967
7968       /* Compute and store the initial value.  */
7969       already_used = TREE_USED (decl) || TREE_USED (type);
7970
7971       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7972         {
7973           int saved_stmts_are_full_exprs_p;
7974
7975           emit_line_note (DECL_SOURCE_FILE (decl),
7976                           DECL_SOURCE_LINE (decl));
7977           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7978           current_stmt_tree->stmts_are_full_exprs_p = 1;
7979           if (building_stmt_tree ())
7980             finish_expr_stmt (build_aggr_init (decl, init, flags));
7981           else
7982             genrtl_expr_stmt (build_aggr_init (decl, init, flags));
7983           current_stmt_tree->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 == error_mark_node
8017       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8018     return;
8019
8020   if (TREE_CODE (decl) == VAR_DECL &&
8021       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8022     /* We don't clean up things that aren't defined in this
8023        translation unit, or that need a static cleanup.  The latter
8024        are handled by finish_file.  */
8025     return;
8026
8027   /* Compute the cleanup.  */
8028   cleanup = maybe_build_cleanup (decl);
8029
8030   /* Record the cleanup required for this declaration.  */
8031   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8032       && cleanup)
8033     finish_decl_cleanup (decl, cleanup);
8034 }
8035
8036 /* Finish processing of a declaration;
8037    install its line number and initial value.
8038    If the length of an array type is not known before,
8039    it must be determined now, from the initial value, or it is an error.
8040
8041    INIT0 holds the value of an initializer that should be allowed to escape
8042    the normal rules.
8043
8044    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8045    if the (init) syntax was used.  */
8046
8047 void
8048 cp_finish_decl (decl, init, asmspec_tree, flags)
8049      tree decl, init;
8050      tree asmspec_tree;
8051      int flags;
8052 {
8053   register tree type;
8054   tree ttype = NULL_TREE;
8055   const char *asmspec = NULL;
8056   int was_readonly = 0;
8057
8058   if (! decl)
8059     {
8060       if (init)
8061         error ("assignment (not initialization) in declaration");
8062       return;
8063     }
8064
8065   /* If a name was specified, get the string.  */
8066   if (asmspec_tree)
8067       asmspec = TREE_STRING_POINTER (asmspec_tree);
8068
8069   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8070     {
8071       cp_error ("cannot initialize `%D' to namespace `%D'",
8072                 decl, init);
8073       init = NULL_TREE;
8074     }
8075
8076   if (current_class_type
8077       && CP_DECL_CONTEXT (decl) == current_class_type
8078       && TYPE_BEING_DEFINED (current_class_type)
8079       && (DECL_INITIAL (decl) || init))
8080     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8081
8082   if (TREE_CODE (decl) == VAR_DECL
8083       && DECL_CONTEXT (decl)
8084       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8085       && DECL_CONTEXT (decl) != current_namespace
8086       && init)
8087     {
8088       /* Leave the namespace of the object. */
8089       pop_decl_namespace ();
8090     }
8091
8092   type = TREE_TYPE (decl);
8093
8094   if (type == error_mark_node)
8095     return;
8096
8097   /* Add this declaration to the statement-tree.  */
8098   if (building_stmt_tree () && at_function_scope_p ())
8099     add_decl_stmt (decl);
8100
8101   if (TYPE_HAS_MUTABLE_P (type))
8102     TREE_READONLY (decl) = 0;
8103
8104   if (processing_template_decl)
8105     {
8106       if (init && DECL_INITIAL (decl))
8107         DECL_INITIAL (decl) = init;
8108       goto finish_end0;
8109     }
8110
8111   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8112   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8113
8114   /* Take care of TYPE_DECLs up front.  */
8115   if (TREE_CODE (decl) == TYPE_DECL)
8116     {
8117       if (init && DECL_INITIAL (decl))
8118         {
8119           /* typedef foo = bar; store the type of bar as the type of foo.  */
8120           TREE_TYPE (decl) = type = TREE_TYPE (init);
8121           DECL_INITIAL (decl) = init = NULL_TREE;
8122         }
8123       if (type != error_mark_node
8124           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8125         {
8126           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8127             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8128           set_identifier_type_value (DECL_NAME (decl), type);
8129           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8130         }
8131       GNU_xref_decl (current_function_decl, decl);
8132
8133       /* If we have installed this as the canonical typedef for this
8134          type, and that type has not been defined yet, delay emitting
8135          the debug information for it, as we will emit it later.  */
8136       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8137           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8138         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8139
8140       rest_of_decl_compilation (decl, NULL_PTR,
8141                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8142       goto finish_end;
8143     }
8144
8145   if (TREE_CODE (decl) != FUNCTION_DECL)
8146     ttype = target_type (type);
8147
8148   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8149       && TYPE_NEEDS_CONSTRUCTING (type))
8150     {
8151       /* Currently, GNU C++ puts constants in text space, making them
8152          impossible to initialize.  In the future, one would hope for
8153          an operating system which understood the difference between
8154          initialization and the running of a program.  */
8155       was_readonly = 1;
8156       TREE_READONLY (decl) = 0;
8157     }
8158
8159   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8160     {
8161       /* This must override the asm specifier which was placed by
8162          grokclassfn.  Lay this out fresh.  */
8163       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8164       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8165       make_decl_rtl (decl, asmspec, 0);
8166     }
8167
8168   /* Deduce size of array from initialization, if not already known.  */
8169   maybe_deduce_size_from_array_init (decl, init);
8170   init = check_initializer (decl, init);
8171
8172   GNU_xref_decl (current_function_decl, decl);
8173
8174   if (TREE_CODE (decl) == VAR_DECL)
8175     layout_var_decl (decl);
8176
8177   /* Output the assembler code and/or RTL code for variables and functions,
8178      unless the type is an undefined structure or union.
8179      If not, it will get done when the type is completed.  */
8180   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8181       || TREE_CODE (decl) == RESULT_DECL)
8182     {
8183       if (TREE_CODE (decl) == VAR_DECL)
8184         maybe_commonize_var (decl);
8185
8186       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8187
8188       if (TREE_CODE (type) == FUNCTION_TYPE
8189           || TREE_CODE (type) == METHOD_TYPE)
8190         abstract_virtuals_error (decl,
8191                                  strip_array_types (TREE_TYPE (type)));
8192       else
8193         abstract_virtuals_error (decl, strip_array_types (type));
8194
8195       if (TREE_CODE (decl) == FUNCTION_DECL)
8196         ;
8197       else if (DECL_EXTERNAL (decl)
8198                && ! (DECL_LANG_SPECIFIC (decl)
8199                      && DECL_NOT_REALLY_EXTERN (decl)))
8200         {
8201           if (init)
8202             DECL_INITIAL (decl) = init;
8203         }
8204       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8205         {
8206           /* This is a local declaration.  */
8207           if (doing_semantic_analysis_p ())
8208             maybe_inject_for_scope_var (decl);
8209           /* Initialize the local variable.  But, if we're building a
8210              statement-tree, we'll do the initialization when we
8211              expand the tree.  */
8212           if (processing_template_decl)
8213             {
8214               if (init || DECL_INITIAL (decl) == error_mark_node)
8215                 DECL_INITIAL (decl) = init;
8216             }
8217           else
8218             {
8219               /* If we're not building RTL, then we need to do so
8220                  now.  */
8221               if (!building_stmt_tree ())
8222                 emit_local_var (decl);
8223               /* Initialize the variable.  */
8224               initialize_local_var (decl, init, flags);
8225               /* Clean up the variable.  */
8226               destroy_local_var (decl);
8227             }
8228         }
8229       else if (TREE_STATIC (decl) && type != error_mark_node)
8230         {
8231           /* Cleanups for static variables are handled by `finish_file'.  */
8232           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8233               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8234             expand_static_init (decl, init);
8235         }
8236     finish_end0:
8237
8238       /* Undo call to `pushclass' that was done in `start_decl'
8239          due to initialization of qualified member variable.
8240          I.e., Foo::x = 10;  */
8241       {
8242         tree context = CP_DECL_CONTEXT (decl);
8243         if (context
8244             && TYPE_P (context)
8245             && (TREE_CODE (decl) == VAR_DECL
8246                 /* We also have a pushclass done that we need to undo here
8247                    if we're at top level and declare a method.  */
8248                 || TREE_CODE (decl) == FUNCTION_DECL)
8249             /* If size hasn't been set, we're still defining it,
8250                and therefore inside the class body; don't pop
8251                the binding level..  */
8252             && COMPLETE_TYPE_P (context)
8253             && context == current_class_type)
8254           pop_nested_class ();
8255       }
8256     }
8257
8258  finish_end:
8259
8260   if (was_readonly)
8261     TREE_READONLY (decl) = 1;
8262 }
8263
8264 /* This is here for a midend callback from c-common.c */
8265
8266 void
8267 finish_decl (decl, init, asmspec_tree)
8268      tree decl, init;
8269      tree asmspec_tree;
8270 {
8271   cp_finish_decl (decl, init, asmspec_tree, 0);
8272 }
8273
8274 /* Returns a declaration for a VAR_DECL as if:
8275
8276      extern "C" TYPE NAME;
8277
8278    had been seen.  Used to create compiler-generated global
8279    variables.  */
8280
8281 tree
8282 declare_global_var (name, type)
8283      tree name;
8284      tree type;
8285 {
8286   tree decl;
8287
8288   push_to_top_level ();
8289   decl = build_decl (VAR_DECL, name, type);
8290   TREE_PUBLIC (decl) = 1;
8291   DECL_EXTERNAL (decl) = 1;
8292   DECL_ARTIFICIAL (decl) = 1;
8293   pushdecl (decl);
8294   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8295   pop_from_top_level ();
8296
8297   return decl;
8298 }
8299
8300 /* Returns a pointer to the `atexit' function.  Note that if
8301    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8302    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8303
8304 static tree
8305 get_atexit_node ()
8306 {
8307   tree atexit_fndecl;
8308   tree arg_types;
8309   tree fn_type;
8310   tree fn_ptr_type;
8311   const char *name;
8312
8313   if (atexit_node)
8314     return atexit_node;
8315
8316   if (flag_use_cxa_atexit)
8317     {
8318       /* The declaration for `__cxa_atexit' is:
8319
8320            int __cxa_atexit (void (*)(void *), void *, void *)
8321
8322          We build up the argument types and then then function type
8323          itself.  */
8324
8325       /* First, build the pointer-to-function type for the first
8326          argument.  */
8327       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8328       fn_type = build_function_type (void_type_node, arg_types);
8329       fn_ptr_type = build_pointer_type (fn_type);
8330       /* Then, build the rest of the argument types.  */
8331       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8332       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8333       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8334       /* And the final __cxa_atexit type.  */
8335       fn_type = build_function_type (integer_type_node, arg_types);
8336       fn_ptr_type = build_pointer_type (fn_type);
8337       name = "__cxa_atexit";
8338     }
8339   else
8340     {
8341       /* The declaration for `atexit' is:
8342
8343            int atexit (void (*)());
8344
8345          We build up the argument types and then then function type
8346          itself.  */
8347       fn_type = build_function_type (void_type_node, void_list_node);
8348       fn_ptr_type = build_pointer_type (fn_type);
8349       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8350       /* Build the final atexit type.  */
8351       fn_type = build_function_type (integer_type_node, arg_types);
8352       name = "atexit";
8353     }
8354
8355   /* Now, build the function declaration.  */
8356   push_lang_context (lang_name_c);
8357   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8358   mark_used (atexit_fndecl);
8359   pop_lang_context ();
8360   atexit_node = default_conversion (atexit_fndecl);
8361
8362   return atexit_node;
8363 }
8364
8365 /* Returns the __dso_handle VAR_DECL.  */
8366
8367 static tree
8368 get_dso_handle_node ()
8369 {
8370   if (dso_handle_node)
8371     return dso_handle_node;
8372
8373   /* Declare the variable.  */
8374   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8375                                         ptr_type_node);
8376
8377   return dso_handle_node;
8378 }
8379
8380 /* Begin a new function with internal linkage whose job will be simply
8381    to destroy some particular variable.  */
8382
8383 static tree
8384 start_cleanup_fn ()
8385 {
8386   static int counter = 0;
8387   int old_interface_unknown = interface_unknown;
8388   char name[32];
8389   tree parmtypes;
8390   tree fntype;
8391   tree fndecl;
8392
8393   push_to_top_level ();
8394
8395   /* No need to mangle this.  */
8396   push_lang_context (lang_name_c);
8397
8398   interface_unknown = 1;
8399
8400   /* Build the parameter-types.  */
8401   parmtypes = void_list_node;
8402   /* Functions passed to __cxa_atexit take an additional parameter.
8403      We'll just ignore it.  After we implement the new calling
8404      convention for destructors, we can eliminate the use of
8405      additional cleanup functions entirely in the -fnew-abi case.  */
8406   if (flag_use_cxa_atexit)
8407     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8408   /* Build the function type itself.  */
8409   fntype = build_function_type (void_type_node, parmtypes);
8410   /* Build the name of the function.  */
8411   sprintf (name, "__tcf_%d", counter++);
8412   /* Build the function declaration.  */
8413   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8414   /* It's a function with internal linkage, generated by the
8415      compiler.  */
8416   TREE_PUBLIC (fndecl) = 0;
8417   DECL_ARTIFICIAL (fndecl) = 1;
8418   /* Build the parameter.  */
8419   if (flag_use_cxa_atexit)
8420     {
8421       tree parmdecl;
8422
8423       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8424       DECL_CONTEXT (parmdecl) = fndecl;
8425       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8426       TREE_USED (parmdecl) = 1;
8427       DECL_ARGUMENTS (fndecl) = parmdecl;
8428     }
8429
8430   pushdecl (fndecl);
8431   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8432   do_pushlevel ();
8433
8434   interface_unknown = old_interface_unknown;
8435
8436   pop_lang_context ();
8437
8438   return current_function_decl;
8439 }
8440
8441 /* Finish the cleanup function begun by start_cleanup_fn.  */
8442
8443 static void
8444 end_cleanup_fn ()
8445 {
8446   do_poplevel ();
8447
8448   expand_body (finish_function (0));
8449
8450   pop_from_top_level ();
8451 }
8452
8453 /* Generate code to handle the destruction of DECL, an object with
8454    static storage duration.  */
8455
8456 void
8457 register_dtor_fn (decl)
8458      tree decl;
8459 {
8460   tree cleanup;
8461   tree compound_stmt;
8462   tree args;
8463   tree fcall;
8464
8465   int saved_flag_access_control;
8466
8467   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8468     return;
8469
8470   /* Call build_cleanup before we enter the anonymous function so that
8471      any access checks will be done relative to the current scope,
8472      rather than the scope of the anonymous function.  */
8473   build_cleanup (decl);
8474
8475   /* Now start the function.  */
8476   cleanup = start_cleanup_fn ();
8477
8478   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8479      to the original function, rather than the anonymous one.  That
8480      will make the back-end think that nested functions are in use,
8481      which causes confusion.  */
8482   saved_flag_access_control = flag_access_control;
8483   flag_access_control = 0;
8484   fcall = build_cleanup (decl);
8485   flag_access_control = saved_flag_access_control;
8486
8487   /* Create the body of the anonymous function.  */
8488   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8489   finish_expr_stmt (fcall);
8490   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8491   end_cleanup_fn ();
8492
8493   /* Call atexit with the cleanup function.  */
8494   mark_addressable (cleanup);
8495   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8496   if (flag_use_cxa_atexit)
8497     {
8498       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8499       args = tree_cons (NULL_TREE, null_pointer_node, args);
8500       args = tree_cons (NULL_TREE, cleanup, args);
8501     }
8502   else
8503     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8504   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8505 }
8506
8507 void
8508 expand_static_init (decl, init)
8509      tree decl;
8510      tree init;
8511 {
8512   tree oldstatic = value_member (decl, static_aggregates);
8513
8514   if (oldstatic)
8515     {
8516       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8517         cp_error ("multiple initializations given for `%D'", decl);
8518     }
8519   else if (! toplevel_bindings_p ())
8520     {
8521       /* Emit code to perform this initialization but once.  */
8522       tree if_stmt;
8523       tree then_clause;
8524       tree assignment;
8525       tree guard;
8526       tree guard_init;
8527
8528       /* Emit code to perform this initialization but once.  This code
8529          looks like:
8530
8531            static int guard = 0;
8532            if (!guard) {
8533              // Do initialization.
8534              guard = 1;
8535              // Register variable for destruction at end of program.
8536            }
8537
8538          Note that the `temp' variable is only set to 1 *after* the
8539          initialization is complete.  This ensures that an exception,
8540          thrown during the construction, will cause the variable to
8541          reinitialized when we pass through this code again, as per:
8542
8543            [stmt.dcl]
8544
8545            If the initialization exits by throwing an exception, the
8546            initialization is not complete, so it will be tried again
8547            the next time control enters the declaration.
8548
8549          In theory, this process should be thread-safe, too; multiple
8550          threads should not be able to initialize the variable more
8551          than once.  We don't yet attempt to ensure thread-safety.  */
8552
8553       /* Create the guard variable.  */
8554       guard = get_guard (decl);
8555
8556       /* Begin the conditional initialization.  */
8557       if_stmt = begin_if_stmt ();
8558       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8559       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8560
8561       /* Do the initialization itself.  */
8562       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8563           || (init && TREE_CODE (init) == TREE_LIST))
8564         assignment = build_aggr_init (decl, init, 0);
8565       else if (init)
8566         /* The initialization we're doing here is just a bitwise
8567            copy.  */
8568         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8569       else
8570         assignment = NULL_TREE;
8571
8572       /* Once the assignment is complete, set TEMP to 1.  Since the
8573          construction of the static object is complete at this point,
8574          we want to make sure TEMP is set to 1 even if a temporary
8575          constructed during the initialization throws an exception
8576          when it is destroyed.  So, we combine the initialization and
8577          the assignment to TEMP into a single expression, ensuring
8578          that when we call finish_expr_stmt the cleanups will not be
8579          run until after TEMP is set to 1.  */
8580       guard_init = set_guard (guard);
8581       if (assignment)
8582         {
8583           assignment = tree_cons (NULL_TREE, assignment,
8584                                   build_tree_list (NULL_TREE,
8585                                                    guard_init));
8586           assignment = build_compound_expr (assignment);
8587         }
8588       else
8589         assignment = guard_init;
8590       finish_expr_stmt (assignment);
8591
8592       /* Use atexit to register a function for destroying this static
8593          variable.  */
8594       register_dtor_fn (decl);
8595
8596       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8597       finish_then_clause (if_stmt);
8598       finish_if_stmt ();
8599     }
8600   else
8601     static_aggregates = tree_cons (init, decl, static_aggregates);
8602 }
8603
8604 /* Finish the declaration of a catch-parameter.  */
8605
8606 tree
8607 start_handler_parms (declspecs, declarator)
8608      tree declspecs;
8609      tree declarator;
8610 {
8611   tree decl;
8612   if (declspecs)
8613     {
8614       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8615                              1, NULL_TREE);
8616       if (decl == NULL_TREE)
8617         error ("invalid catch parameter");
8618     }
8619   else
8620     decl = NULL_TREE;
8621
8622   return decl;
8623 }
8624
8625 \f
8626 /* Make TYPE a complete type based on INITIAL_VALUE.
8627    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8628    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8629
8630 int
8631 complete_array_type (type, initial_value, do_default)
8632      tree type, initial_value;
8633      int do_default;
8634 {
8635   register tree maxindex = NULL_TREE;
8636   int value = 0;
8637
8638   if (initial_value)
8639     {
8640       /* An array of character type can be initialized from a
8641          brace-enclosed string constant.  */
8642       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8643           && TREE_CODE (initial_value) == CONSTRUCTOR
8644           && CONSTRUCTOR_ELTS (initial_value)
8645           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8646               == STRING_CST)
8647           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8648         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8649
8650       /* Note MAXINDEX is really the maximum index, one less than the
8651          size.  */
8652       if (TREE_CODE (initial_value) == STRING_CST)
8653         {
8654           int eltsize
8655             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8656           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8657                                    / eltsize) - 1, 0);
8658         }
8659       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8660         {
8661           tree elts = CONSTRUCTOR_ELTS (initial_value);
8662
8663           maxindex = ssize_int (-1);
8664           for (; elts; elts = TREE_CHAIN (elts))
8665             {
8666               if (TREE_PURPOSE (elts))
8667                 maxindex = TREE_PURPOSE (elts);
8668               else
8669                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8670             }
8671           maxindex = copy_node (maxindex);
8672         }
8673       else
8674         {
8675           /* Make an error message unless that happened already.  */
8676           if (initial_value != error_mark_node)
8677             value = 1;
8678           else
8679             initial_value = NULL_TREE;
8680
8681           /* Prevent further error messages.  */
8682           maxindex = build_int_2 (0, 0);
8683         }
8684     }
8685
8686   if (!maxindex)
8687     {
8688       if (do_default)
8689         maxindex = build_int_2 (0, 0);
8690       value = 2;
8691     }
8692
8693   if (maxindex)
8694     {
8695       tree itype;
8696       tree domain;
8697
8698       domain = build_index_type (maxindex);
8699       TYPE_DOMAIN (type) = domain;
8700
8701       if (! TREE_TYPE (maxindex))
8702         TREE_TYPE (maxindex) = domain;
8703       if (initial_value)
8704         itype = TREE_TYPE (initial_value);
8705       else
8706         itype = NULL;
8707       if (itype && !TYPE_DOMAIN (itype))
8708         TYPE_DOMAIN (itype) = domain;
8709       /* The type of the main variant should never be used for arrays
8710          of different sizes.  It should only ever be completed with the
8711          size of the array.  */
8712       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8713         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8714     }
8715
8716   /* Lay out the type now that we can get the real answer.  */
8717
8718   layout_type (type);
8719
8720   return value;
8721 }
8722 \f
8723 /* Return zero if something is declared to be a member of type
8724    CTYPE when in the context of CUR_TYPE.  STRING is the error
8725    message to print in that case.  Otherwise, quietly return 1.  */
8726
8727 static int
8728 member_function_or_else (ctype, cur_type, flags)
8729      tree ctype, cur_type;
8730      enum overload_flags flags;
8731 {
8732   if (ctype && ctype != cur_type)
8733     {
8734       if (flags == DTOR_FLAG)
8735         error ("destructor for alien class `%s' cannot be a member",
8736                TYPE_NAME_STRING (ctype));
8737       else
8738         error ("constructor for alien class `%s' cannot be a member",
8739                TYPE_NAME_STRING (ctype));
8740       return 0;
8741     }
8742   return 1;
8743 }
8744 \f
8745 /* Subroutine of `grokdeclarator'.  */
8746
8747 /* Generate errors possibly applicable for a given set of specifiers.
8748    This is for ARM $7.1.2.  */
8749
8750 static void
8751 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8752      tree object;
8753      const char *type;
8754      int virtualp, quals, friendp, raises, inlinep;
8755 {
8756   if (virtualp)
8757     cp_error ("`%D' declared as a `virtual' %s", object, type);
8758   if (inlinep)
8759     cp_error ("`%D' declared as an `inline' %s", object, type);
8760   if (quals)
8761     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8762               object, type);
8763   if (friendp)
8764     cp_error_at ("`%D' declared as a friend", object);
8765   if (raises)
8766     cp_error_at ("`%D' declared with an exception specification", object);
8767 }
8768
8769 /* CTYPE is class type, or null if non-class.
8770    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8771    or METHOD_TYPE.
8772    DECLARATOR is the function's name.
8773    VIRTUALP is truthvalue of whether the function is virtual or not.
8774    FLAGS are to be passed through to `grokclassfn'.
8775    QUALS are qualifiers indicating whether the function is `const'
8776    or `volatile'.
8777    RAISES is a list of exceptions that this function can raise.
8778    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8779    not look, and -1 if we should not call `grokclassfn' at all.
8780
8781    Returns `NULL_TREE' if something goes wrong, after issuing
8782    applicable error messages.  */
8783
8784 static tree
8785 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8786             raises, check, friendp, publicp, inlinep, funcdef_flag,
8787             template_count, in_namespace)
8788      tree ctype, type;
8789      tree declarator;
8790      tree orig_declarator;
8791      int virtualp;
8792      enum overload_flags flags;
8793      tree quals, raises;
8794      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8795      tree in_namespace;
8796 {
8797   tree cname, decl;
8798   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8799   int has_default_arg = 0;
8800   tree t;
8801
8802   if (ctype)
8803     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8804       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8805   else
8806     cname = NULL_TREE;
8807
8808   if (raises)
8809     {
8810       type = build_exception_variant (type, raises);
8811     }
8812
8813   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8814   /* Propagate volatile out from type to decl. */
8815   if (TYPE_VOLATILE (type))
8816     TREE_THIS_VOLATILE (decl) = 1;
8817
8818   /* If this decl has namespace scope, set that up.  */
8819   if (in_namespace)
8820     set_decl_namespace (decl, in_namespace, friendp);
8821   else if (!ctype)
8822     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8823
8824   /* `main' and builtins have implicit 'C' linkage.  */
8825   if ((MAIN_NAME_P (declarator)
8826        || (IDENTIFIER_LENGTH (declarator) > 10
8827            && IDENTIFIER_POINTER (declarator)[0] == '_'
8828            && IDENTIFIER_POINTER (declarator)[1] == '_'
8829            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8830       && current_lang_name == lang_name_cplusplus
8831       && ctype == NULL_TREE
8832       /* NULL_TREE means global namespace.  */
8833       && DECL_CONTEXT (decl) == NULL_TREE)
8834     DECL_LANGUAGE (decl) = lang_c;
8835
8836   /* Should probably propagate const out from type to decl I bet (mrs).  */
8837   if (staticp)
8838     {
8839       DECL_STATIC_FUNCTION_P (decl) = 1;
8840       DECL_CONTEXT (decl) = ctype;
8841     }
8842
8843   if (ctype)
8844     DECL_CONTEXT (decl) = ctype;
8845
8846   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8847     {
8848       if (processing_template_decl)
8849         error ("cannot declare `::main' to be a template");
8850       if (inlinep)
8851         error ("cannot declare `::main' to be inline");
8852       else if (! publicp)
8853         error ("cannot declare `::main' to be static");
8854       inlinep = 0;
8855       publicp = 1;
8856     }
8857
8858   /* Members of anonymous types and local classes have no linkage; make
8859      them internal.  */
8860   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8861                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8862     publicp = 0;
8863
8864   if (publicp)
8865     {
8866       /* [basic.link]: A name with no linkage (notably, the name of a class
8867          or enumeration declared in a local scope) shall not be used to
8868          declare an entity with linkage.
8869
8870          Only check this for public decls for now.  */
8871       t = no_linkage_check (TREE_TYPE (decl));
8872       if (t)
8873         {
8874           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8875             {
8876               if (DECL_EXTERN_C_P (decl))
8877                 /* Allow this; it's pretty common in C.  */;
8878               else
8879                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8880                             decl);
8881             }
8882           else
8883             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8884                         decl, t);
8885         }
8886     }
8887
8888   TREE_PUBLIC (decl) = publicp;
8889   if (! publicp)
8890     {
8891       DECL_INTERFACE_KNOWN (decl) = 1;
8892       DECL_NOT_REALLY_EXTERN (decl) = 1;
8893     }
8894
8895   if (inlinep)
8896     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8897
8898   DECL_EXTERNAL (decl) = 1;
8899   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8900     {
8901       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8902                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8903       quals = NULL_TREE;
8904     }
8905
8906   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8907     grok_op_properties (decl, virtualp, check < 0);
8908
8909   if (ctype && decl_function_context (decl))
8910     DECL_NO_STATIC_CHAIN (decl) = 1;
8911
8912   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8913     if (TREE_PURPOSE (t)
8914         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8915       {
8916         has_default_arg = 1;
8917         break;
8918       }
8919
8920   if (friendp
8921       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8922     {
8923       if (funcdef_flag)
8924         cp_error
8925           ("defining explicit specialization `%D' in friend declaration",
8926            orig_declarator);
8927       else
8928         {
8929           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8930             {
8931               /* Something like `template <class T> friend void f<T>()'.  */
8932               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8933                         orig_declarator);
8934               return NULL_TREE;
8935             }
8936
8937
8938           /* A friend declaration of the form friend void f<>().  Record
8939              the information in the TEMPLATE_ID_EXPR.  */
8940           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8941           DECL_TEMPLATE_INFO (decl)
8942             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8943                          TREE_OPERAND (orig_declarator, 1),
8944                          NULL_TREE);
8945
8946           if (has_default_arg)
8947             {
8948               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8949                         decl);
8950               return NULL_TREE;
8951             }
8952
8953           if (inlinep)
8954             {
8955               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8956                         decl);
8957               return NULL_TREE;
8958             }
8959         }
8960     }
8961
8962   if (has_default_arg)
8963     add_defarg_fn (decl);
8964
8965   /* Plain overloading: will not be grok'd by grokclassfn.  */
8966   if (! ctype && ! processing_template_decl
8967       && !DECL_EXTERN_C_P (decl)
8968       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8969     set_mangled_name_for_decl (decl);
8970
8971   if (funcdef_flag)
8972     /* Make the init_value nonzero so pushdecl knows this is not
8973        tentative.  error_mark_node is replaced later with the BLOCK.  */
8974     DECL_INITIAL (decl) = error_mark_node;
8975
8976   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8977     TREE_NOTHROW (decl) = 1;
8978
8979   /* Caller will do the rest of this.  */
8980   if (check < 0)
8981     return decl;
8982
8983   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8984     DECL_CONSTRUCTOR_P (decl) = 1;
8985
8986   /* Function gets the ugly name, field gets the nice one.  This call
8987      may change the type of the function (because of default
8988      parameters)!  */
8989   if (ctype != NULL_TREE)
8990     grokclassfn (ctype, decl, flags, quals);
8991
8992   decl = check_explicit_specialization (orig_declarator, decl,
8993                                         template_count,
8994                                         2 * (funcdef_flag != 0) +
8995                                         4 * (friendp != 0));
8996   if (decl == error_mark_node)
8997     return NULL_TREE;
8998
8999   if (ctype != NULL_TREE
9000       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9001       && check)
9002     {
9003       tree old_decl;
9004
9005       old_decl = check_classfn (ctype, decl);
9006
9007       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9008         /* Because grokfndecl is always supposed to return a
9009            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9010            here.  We depend on our callers to figure out that its
9011            really a template that's being returned.  */
9012         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9013
9014       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9015           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9016         {
9017           /* Remove the `this' parm added by grokclassfn.
9018              XXX Isn't this done in start_function, too?  */
9019           revert_static_member_fn (decl);
9020           last_function_parms = TREE_CHAIN (last_function_parms);
9021         }
9022       if (old_decl && DECL_ARTIFICIAL (old_decl))
9023         cp_error ("definition of implicitly-declared `%D'", old_decl);
9024
9025       if (old_decl)
9026         {
9027           /* Since we've smashed OLD_DECL to its
9028              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9029           if (TREE_CODE (decl) == TEMPLATE_DECL)
9030             decl = DECL_TEMPLATE_RESULT (decl);
9031
9032           /* Attempt to merge the declarations.  This can fail, in
9033              the case of some illegal specialization declarations.  */
9034           if (!duplicate_decls (decl, old_decl))
9035             cp_error ("no `%#D' member function declared in class `%T'",
9036                       decl, ctype);
9037           return old_decl;
9038         }
9039     }
9040
9041   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9042     return NULL_TREE;
9043
9044   if (ctype == NULL_TREE || check)
9045     return decl;
9046
9047   if (virtualp)
9048     {
9049       DECL_VIRTUAL_P (decl) = 1;
9050       if (DECL_VINDEX (decl) == NULL_TREE)
9051         DECL_VINDEX (decl) = error_mark_node;
9052       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9053     }
9054
9055   return decl;
9056 }
9057
9058 static tree
9059 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9060      tree type;
9061      tree declarator;
9062      RID_BIT_TYPE *specbits_in;
9063      int initialized;
9064      int constp;
9065      tree in_namespace;
9066 {
9067   tree decl;
9068   RID_BIT_TYPE specbits;
9069
9070   specbits = *specbits_in;
9071
9072   if (TREE_CODE (type) == OFFSET_TYPE)
9073     {
9074       /* If you declare a static member so that it
9075          can be initialized, the code will reach here.  */
9076       tree basetype = TYPE_OFFSET_BASETYPE (type);
9077       type = TREE_TYPE (type);
9078       decl = build_lang_decl (VAR_DECL, declarator, type);
9079       DECL_CONTEXT (decl) = basetype;
9080       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9081          templates.  */
9082       if (!uses_template_parms (decl))
9083         {
9084           if (flag_new_abi)
9085             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9086           else
9087             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9088                                                             declarator);
9089         }
9090     }
9091   else
9092     {
9093       tree context;
9094
9095       if (in_namespace)
9096         context = in_namespace;
9097       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9098         context = current_namespace;
9099       else
9100         context = NULL_TREE;
9101
9102       if (processing_template_decl && context)
9103         /* For global variables, declared in a template, we need the
9104            full lang_decl.  */
9105         decl = build_lang_decl (VAR_DECL, declarator, type);
9106       else
9107         decl = build_decl (VAR_DECL, declarator, type);
9108
9109       if (context)
9110         set_decl_namespace (decl, context, 0);
9111
9112       context = DECL_CONTEXT (decl);
9113       if (declarator && context && current_lang_name != lang_name_c)
9114         {
9115           if (flag_new_abi)
9116             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9117           else
9118             DECL_ASSEMBLER_NAME (decl)
9119               = build_static_name (context, declarator);
9120         }
9121     }
9122
9123   if (in_namespace)
9124     set_decl_namespace (decl, in_namespace, 0);
9125
9126   if (RIDBIT_SETP (RID_EXTERN, specbits))
9127     {
9128       DECL_THIS_EXTERN (decl) = 1;
9129       DECL_EXTERNAL (decl) = !initialized;
9130     }
9131
9132   /* In class context, static means one per class,
9133      public access, and static storage.  */
9134   if (DECL_CLASS_SCOPE_P (decl))
9135     {
9136       TREE_PUBLIC (decl) = 1;
9137       TREE_STATIC (decl) = 1;
9138       DECL_EXTERNAL (decl) = 0;
9139     }
9140   /* At top level, either `static' or no s.c. makes a definition
9141      (perhaps tentative), and absence of `static' makes it public.  */
9142   else if (toplevel_bindings_p ())
9143     {
9144       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9145                             && (DECL_THIS_EXTERN (decl) || ! constp));
9146       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9147     }
9148   /* Not at top level, only `static' makes a static definition.  */
9149   else
9150     {
9151       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9152       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9153     }
9154
9155   if (TREE_PUBLIC (decl))
9156     {
9157       /* [basic.link]: A name with no linkage (notably, the name of a class
9158          or enumeration declared in a local scope) shall not be used to
9159          declare an entity with linkage.
9160
9161          Only check this for public decls for now.  */
9162       tree t = no_linkage_check (TREE_TYPE (decl));
9163       if (t)
9164         {
9165           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9166             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9167           else
9168             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9169                         decl, t);
9170         }
9171     }
9172
9173   return decl;
9174 }
9175
9176 /* Create and return a canonical pointer to member function type, for
9177    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9178
9179 tree
9180 build_ptrmemfunc_type (type)
9181      tree type;
9182 {
9183   tree fields[4];
9184   tree t;
9185   tree u;
9186   tree unqualified_variant = NULL_TREE;
9187
9188   /* If a canonical type already exists for this type, use it.  We use
9189      this method instead of type_hash_canon, because it only does a
9190      simple equality check on the list of field members.  */
9191
9192   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9193     return t;
9194
9195   /* Make sure that we always have the unqualified pointer-to-member
9196      type first.  */
9197   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9198     unqualified_variant
9199       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9200
9201   t = make_aggr_type (RECORD_TYPE);
9202   /* Let the front-end know this is a pointer to member function...  */
9203   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9204   /* ... and not really an aggregate.  */
9205   SET_IS_AGGR_TYPE (t, 0);
9206
9207   if (!flag_new_abi)
9208     {
9209       u = make_aggr_type (UNION_TYPE);
9210       SET_IS_AGGR_TYPE (u, 0);
9211       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9212       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9213                               delta_type_node);
9214       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9215       TYPE_NAME (u) = NULL_TREE;
9216
9217       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9218                               delta_type_node);
9219       fields[1] = build_decl (FIELD_DECL, index_identifier,
9220                               delta_type_node);
9221       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9222       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9223     }
9224   else
9225     {
9226       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9227       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9228                               delta_type_node);
9229       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9230     }
9231
9232   /* Zap out the name so that the back-end will give us the debugging
9233      information for this anonymous RECORD_TYPE.  */
9234   TYPE_NAME (t) = NULL_TREE;
9235
9236   /* If this is not the unqualified form of this pointer-to-member
9237      type, set the TYPE_MAIN_VARIANT for this type to be the
9238      unqualified type.  Since they are actually RECORD_TYPEs that are
9239      not variants of each other, we must do this manually.  */
9240   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9241     {
9242       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9243       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9244       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9245       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9246     }
9247
9248   /* Cache this pointer-to-member type so that we can find it again
9249      later.  */
9250   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9251
9252   /* Seems to be wanted.  */
9253   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9254
9255   return t;
9256 }
9257
9258 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9259    Check to see that the definition is valid.  Issue appropriate error
9260    messages.  Return 1 if the definition is particularly bad, or 0
9261    otherwise.  */
9262
9263 int
9264 check_static_variable_definition (decl, type)
9265      tree decl;
9266      tree type;
9267 {
9268   /* Motion 10 at San Diego: If a static const integral data member is
9269      initialized with an integral constant expression, the initializer
9270      may appear either in the declaration (within the class), or in
9271      the definition, but not both.  If it appears in the class, the
9272      member is a member constant.  The file-scope definition is always
9273      required.  */
9274   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9275     {
9276       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9277                 type);
9278       /* If we just return the declaration, crashes will sometimes
9279          occur.  We therefore return void_type_node, as if this was a
9280          friend declaration, to cause callers to completely ignore
9281          this declaration.  */
9282       return 1;
9283     }
9284   else if (!CP_TYPE_CONST_P (type))
9285     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9286               decl);
9287   else if (pedantic && !INTEGRAL_TYPE_P (type))
9288     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9289
9290   return 0;
9291 }
9292
9293 /* Given the SIZE (i.e., number of elements) in an array, compute an
9294    appropriate index type for the array.  If non-NULL, NAME is the
9295    name of the thing being declared.  */
9296
9297 tree
9298 compute_array_index_type (name, size)
9299      tree name;
9300      tree size;
9301 {
9302   tree itype;
9303
9304   /* The size might be the result of a cast. */
9305   STRIP_TYPE_NOPS (size);
9306
9307   /* It might be a const variable or enumeration constant.  */
9308   size = decl_constant_value (size);
9309
9310   /* If this involves a template parameter, it will be a constant at
9311      instantiation time, but we don't know what the value is yet.
9312      Even if no template parameters are involved, we may an expression
9313      that is not a constant; we don't even simplify `1 + 2' when
9314      processing a template.  */
9315   if (processing_template_decl)
9316     {
9317       /* Resolve a qualified reference to an enumerator or static
9318          const data member of ours.  */
9319       if (TREE_CODE (size) == SCOPE_REF
9320           && TREE_OPERAND (size, 0) == current_class_type)
9321         {
9322           tree t = lookup_field (current_class_type,
9323                                  TREE_OPERAND (size, 1), 0, 0);
9324           if (t)
9325             size = t;
9326         }
9327
9328       return build_index_type (build_min (MINUS_EXPR, sizetype,
9329                                           size, integer_one_node));
9330     }
9331
9332   /* The array bound must be an integer type.  */
9333   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9334       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9335       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9336     {
9337       if (name)
9338         cp_error ("size of array `%D' has non-integer type", name);
9339       else
9340         cp_error ("size of array has non-integer type");
9341       size = integer_one_node;
9342     }
9343
9344   /* Normally, the array-bound will be a constant.  */
9345   if (TREE_CODE (size) == INTEGER_CST)
9346     {
9347       /* Check to see if the array bound overflowed.  Make that an
9348          error, no matter how generous we're being.  */
9349       int old_flag_pedantic_errors = flag_pedantic_errors;
9350       int old_pedantic = pedantic;
9351       pedantic = flag_pedantic_errors = 1;
9352       constant_expression_warning (size);
9353       pedantic = old_pedantic;
9354       flag_pedantic_errors = old_flag_pedantic_errors;
9355
9356       /* An array must have a positive number of elements.  */
9357       if (INT_CST_LT (size, integer_zero_node))
9358         {
9359           if (name)
9360             cp_error ("size of array `%D' is negative", name);
9361           else
9362             cp_error ("size of array is negative");
9363           size = integer_one_node;
9364         }
9365       /* Except that an extension we allow zero-sized arrays.  We
9366          always allow them in system headers because glibc uses
9367          them.  */
9368       else if (integer_zerop (size) && pedantic && !in_system_header)
9369         {
9370           if (name)
9371             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9372           else
9373             cp_pedwarn ("ISO C++ forbids zero-size array");
9374         }
9375     }
9376   else if (TREE_CONSTANT (size))
9377     {
9378       /* `(int) &fn' is not a valid array bound.  */
9379       if (name)
9380         cp_error ("size of array `%D' is not an integral constant-expression",
9381                   name);
9382       else
9383         cp_error ("size of array is not an integral constant-expression");
9384     }
9385
9386   /* Compute the index of the largest element in the array.  It is
9387      one less than the number of elements in the array.  */
9388   itype
9389     = fold (cp_build_binary_op (MINUS_EXPR,
9390                                 cp_convert (ssizetype, size),
9391                                 cp_convert (ssizetype,
9392                                             integer_one_node)));
9393
9394   /* Check for variable-sized arrays.  We allow such things as an
9395      extension, even though they are not allowed in ANSI/ISO C++.  */
9396   if (!TREE_CONSTANT (itype))
9397     {
9398       if (pedantic)
9399         {
9400           if (name)
9401             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9402                         name);
9403           else
9404             cp_pedwarn ("ISO C++ forbids variable-size array");
9405         }
9406
9407       /* Create a variable-sized array index type.  */
9408       itype = variable_size (itype);
9409     }
9410   /* Make sure that there was no overflow when creating to a signed
9411      index type.  (For example, on a 32-bit machine, an array with
9412      size 2^32 - 1 is too big.)  */
9413   else if (TREE_OVERFLOW (itype))
9414     {
9415       error ("overflow in array dimension");
9416       TREE_OVERFLOW (itype) = 0;
9417     }
9418
9419   /* Create and return the appropriate index type.  */
9420   return build_index_type (itype);
9421 }
9422
9423 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9424    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9425    with this type.  */
9426
9427 static tree
9428 create_array_type_for_decl (name, type, size)
9429      tree name;
9430      tree type;
9431      tree size;
9432 {
9433   tree itype = NULL_TREE;
9434   const char* error_msg;
9435
9436   /* If things have already gone awry, bail now.  */
9437   if (type == error_mark_node || size == error_mark_node)
9438     return error_mark_node;
9439
9440   /* Assume that everything will go OK.  */
9441   error_msg = NULL;
9442
9443   /* There are some types which cannot be array elements.  */
9444   switch (TREE_CODE (type))
9445     {
9446     case VOID_TYPE:
9447       error_msg = "array of void";
9448       break;
9449
9450     case FUNCTION_TYPE:
9451       error_msg = "array of functions";
9452       break;
9453
9454     case REFERENCE_TYPE:
9455       error_msg = "array of references";
9456       break;
9457
9458     case OFFSET_TYPE:
9459       error_msg = "array of data members";
9460       break;
9461
9462     case METHOD_TYPE:
9463       error_msg = "array of function members";
9464       break;
9465
9466     default:
9467       break;
9468     }
9469
9470   /* If something went wrong, issue an error-message and return.  */
9471   if (error_msg)
9472     {
9473       if (name)
9474         cp_error ("declaration of `%D' as %s", name, error_msg);
9475       else
9476         cp_error ("creating %s", error_msg);
9477
9478       return error_mark_node;
9479     }
9480
9481   /* [dcl.array]
9482
9483      The constant expressions that specify the bounds of the arrays
9484      can be omitted only for the first member of the sequence.  */
9485   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9486     {
9487       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9488                 name);
9489
9490       return error_mark_node;
9491     }
9492
9493   /* Figure out the index type for the array.  */
9494   if (size)
9495     itype = compute_array_index_type (name, size);
9496
9497   return build_cplus_array_type (type, itype);
9498 }
9499
9500 /* Check that it's OK to declare a function with the indicated TYPE.
9501    SFK indicates the kind of special function (if any) that this
9502    function is.  CTYPE is the class of which this function is a
9503    member.  OPTYPE is the type given in a conversion operator
9504    declaration.  Returns the actual return type of the function; that
9505    may be different than TYPE if an error occurs, or for certain
9506    special functions.  */
9507
9508 static tree
9509 check_special_function_return_type (sfk, type, ctype, optype)
9510      special_function_kind sfk;
9511      tree type;
9512      tree ctype;
9513      tree optype;
9514 {
9515   switch (sfk)
9516     {
9517     case sfk_constructor:
9518       if (type)
9519         cp_error ("return type specification for constructor invalid");
9520
9521       /* In the old ABI, we return `this'; in the new ABI we don't
9522          bother.  */
9523       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9524       break;
9525
9526     case sfk_destructor:
9527       if (type)
9528         cp_error ("return type specification for destructor invalid");
9529       type = void_type_node;
9530       break;
9531
9532     case sfk_conversion:
9533       if (type && !same_type_p (type, optype))
9534         cp_error ("operator `%T' declared to return `%T'", optype, type);
9535       else if (type)
9536         cp_pedwarn ("return type specified for `operator %T'",  optype);
9537       type = optype;
9538       break;
9539
9540     default:
9541       my_friendly_abort (20000408);
9542       break;
9543     }
9544
9545   return type;
9546 }
9547
9548 /* Given declspecs and a declarator,
9549    determine the name and type of the object declared
9550    and construct a ..._DECL node for it.
9551    (In one case we can return a ..._TYPE node instead.
9552     For invalid input we sometimes return 0.)
9553
9554    DECLSPECS is a chain of tree_list nodes whose value fields
9555     are the storage classes and type specifiers.
9556
9557    DECL_CONTEXT says which syntactic context this declaration is in:
9558      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9559      FUNCDEF for a function definition.  Like NORMAL but a few different
9560       error messages in each case.  Return value may be zero meaning
9561       this definition is too screwy to try to parse.
9562      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9563       handle member functions (which have FIELD context).
9564       Return value may be zero meaning this definition is too screwy to
9565       try to parse.
9566      PARM for a parameter declaration (either within a function prototype
9567       or before a function body).  Make a PARM_DECL, or return void_type_node.
9568      CATCHPARM for a parameter declaration before a catch clause.
9569      TYPENAME if for a typename (in a cast or sizeof).
9570       Don't make a DECL node; just return the ..._TYPE node.
9571      FIELD for a struct or union field; make a FIELD_DECL.
9572      BITFIELD for a field with specified width.
9573    INITIALIZED is 1 if the decl has an initializer.
9574
9575    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9576    normal attributes in TREE_PURPOSE, or NULL_TREE.
9577
9578    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9579    It may also be so in the PARM case, for a prototype where the
9580    argument type is specified but not the name.
9581
9582    This function is where the complicated C meanings of `static'
9583    and `extern' are interpreted.
9584
9585    For C++, if there is any monkey business to do, the function which
9586    calls this one must do it, i.e., prepending instance variables,
9587    renaming overloaded function names, etc.
9588
9589    Note that for this C++, it is an error to define a method within a class
9590    which does not belong to that class.
9591
9592    Except in the case where SCOPE_REFs are implicitly known (such as
9593    methods within a class being redundantly qualified),
9594    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9595    (class_name::decl_name).  The caller must also deal with this.
9596
9597    If a constructor or destructor is seen, and the context is FIELD,
9598    then the type gains the attribute TREE_HAS_x.  If such a declaration
9599    is erroneous, NULL_TREE is returned.
9600
9601    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9602    function, these are the qualifiers to give to the `this' pointer. We
9603    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9604
9605    May return void_type_node if the declarator turned out to be a friend.
9606    See grokfield for details.  */
9607
9608 tree
9609 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9610      tree declspecs;
9611      tree declarator;
9612      enum decl_context decl_context;
9613      int initialized;
9614      tree attrlist;
9615 {
9616   RID_BIT_TYPE specbits;
9617   int nclasses = 0;
9618   tree spec;
9619   tree type = NULL_TREE;
9620   int longlong = 0;
9621   int constp;
9622   int restrictp;
9623   int volatilep;
9624   int type_quals;
9625   int virtualp, explicitp, friendp, inlinep, staticp;
9626   int explicit_int = 0;
9627   int explicit_char = 0;
9628   int defaulted_int = 0;
9629   tree typedef_decl = NULL_TREE;
9630   const char *name;
9631   tree typedef_type = NULL_TREE;
9632   int funcdef_flag = 0;
9633   enum tree_code innermost_code = ERROR_MARK;
9634   int bitfield = 0;
9635 #if 0
9636   /* See the code below that used this.  */
9637   tree decl_machine_attr = NULL_TREE;
9638 #endif
9639   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9640      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9641   tree init = NULL_TREE;
9642
9643   /* Keep track of what sort of function is being processed
9644      so that we can warn about default return values, or explicit
9645      return values which do not match prescribed defaults.  */
9646   special_function_kind sfk = sfk_none;
9647
9648   tree dname = NULL_TREE;
9649   tree ctype = current_class_type;
9650   tree ctor_return_type = NULL_TREE;
9651   enum overload_flags flags = NO_SPECIAL;
9652   tree quals = NULL_TREE;
9653   tree raises = NULL_TREE;
9654   int template_count = 0;
9655   tree in_namespace = NULL_TREE;
9656   tree inner_attrs;
9657   int ignore_attrs;
9658
9659   RIDBIT_RESET_ALL (specbits);
9660   if (decl_context == FUNCDEF)
9661     funcdef_flag = 1, decl_context = NORMAL;
9662   else if (decl_context == MEMFUNCDEF)
9663     funcdef_flag = -1, decl_context = FIELD;
9664   else if (decl_context == BITFIELD)
9665     bitfield = 1, decl_context = FIELD;
9666
9667   /* Look inside a declarator for the name being declared
9668      and get it as a string, for an error message.  */
9669   {
9670     tree *next = &declarator;
9671     register tree decl;
9672     name = NULL;
9673
9674     while (next && *next)
9675       {
9676         decl = *next;
9677         switch (TREE_CODE (decl))
9678           {
9679           case TREE_LIST:
9680             /* For attributes.  */
9681             next = &TREE_VALUE (decl);
9682             break;
9683
9684           case COND_EXPR:
9685             ctype = NULL_TREE;
9686             next = &TREE_OPERAND (decl, 0);
9687             break;
9688
9689           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9690             {
9691               tree name = TREE_OPERAND (decl, 0);
9692               tree rename = NULL_TREE;
9693
9694               my_friendly_assert (flags == NO_SPECIAL, 152);
9695               flags = DTOR_FLAG;
9696               sfk = sfk_destructor;
9697               if (TREE_CODE (name) == TYPE_DECL)
9698                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9699               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9700               if (ctype == NULL_TREE)
9701                 {
9702                   if (current_class_type == NULL_TREE)
9703                     {
9704                       error ("destructors must be member functions");
9705                       flags = NO_SPECIAL;
9706                     }
9707                   else
9708                     {
9709                       tree t = constructor_name (current_class_name);
9710                       if (t != name)
9711                         rename = t;
9712                     }
9713                 }
9714               else
9715                 {
9716                   tree t = constructor_name (ctype);
9717                   if (t != name)
9718                     rename = t;
9719                 }
9720
9721               if (rename)
9722                 {
9723                   cp_error ("destructor `%T' must match class name `%T'",
9724                             name, rename);
9725                   TREE_OPERAND (decl, 0) = rename;
9726                 }
9727               next = &name;
9728             }
9729             break;
9730
9731           case ADDR_EXPR:       /* C++ reference declaration */
9732             /* Fall through. */
9733           case ARRAY_REF:
9734           case INDIRECT_REF:
9735             ctype = NULL_TREE;
9736             innermost_code = TREE_CODE (decl);
9737             next = &TREE_OPERAND (decl, 0);
9738             break;
9739
9740           case CALL_EXPR:
9741             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9742               {
9743                 /* This is actually a variable declaration using
9744                    constructor syntax.  We need to call start_decl and
9745                    cp_finish_decl so we can get the variable
9746                    initialized...  */
9747
9748                 tree attributes, prefix_attributes;
9749
9750                 *next = TREE_OPERAND (decl, 0);
9751                 init = CALL_DECLARATOR_PARMS (decl);
9752
9753                 if (attrlist)
9754                   {
9755                     attributes = TREE_PURPOSE (attrlist);
9756                     prefix_attributes = TREE_VALUE (attrlist);
9757                   }
9758                 else
9759                   {
9760                     attributes = NULL_TREE;
9761                     prefix_attributes = NULL_TREE;
9762                   }
9763
9764                 decl = start_decl (declarator, declspecs, 1,
9765                                    attributes, prefix_attributes);
9766                 decl_type_access_control (decl);
9767                 if (decl)
9768                   {
9769                     /* Look for __unused__ attribute */
9770                     if (TREE_USED (TREE_TYPE (decl)))
9771                       TREE_USED (decl) = 1;
9772                     finish_decl (decl, init, NULL_TREE);
9773                   }
9774                 else
9775                   cp_error ("invalid declarator");
9776                 return 0;
9777               }
9778             innermost_code = TREE_CODE (decl);
9779             if (decl_context == FIELD && ctype == NULL_TREE)
9780               ctype = current_class_type;
9781             if (ctype
9782                 && TREE_OPERAND (decl, 0)
9783                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9784                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9785                          == constructor_name_full (ctype))
9786                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9787                             == constructor_name (ctype)))))
9788               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9789             next = &TREE_OPERAND (decl, 0);
9790             decl = *next;
9791             if (ctype != NULL_TREE
9792                 && decl != NULL_TREE && flags != DTOR_FLAG
9793                 && decl == constructor_name (ctype))
9794               {
9795                 sfk = sfk_constructor;
9796                 ctor_return_type = ctype;
9797               }
9798             ctype = NULL_TREE;
9799             break;
9800
9801           case TEMPLATE_ID_EXPR:
9802               {
9803                 tree fns = TREE_OPERAND (decl, 0);
9804
9805                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9806                   fns = TREE_OPERAND (fns, 0);
9807
9808                 dname = fns;
9809                 if (TREE_CODE (dname) == COMPONENT_REF)
9810                   dname = TREE_OPERAND (dname, 1);
9811                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9812                   {
9813                     my_friendly_assert (is_overloaded_fn (dname),
9814                                         19990331);
9815                     dname = DECL_NAME (get_first_fn (dname));
9816                   }
9817               }
9818           /* Fall through. */
9819
9820           case IDENTIFIER_NODE:
9821             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9822               dname = decl;
9823
9824             next = 0;
9825
9826             if (is_rid (dname))
9827               {
9828                 cp_error ("declarator-id missing; using reserved word `%D'",
9829                           dname);
9830                 name = IDENTIFIER_POINTER (dname);
9831               }
9832             else if (!IDENTIFIER_TYPENAME_P (dname))
9833               name = IDENTIFIER_POINTER (dname);
9834             else
9835               {
9836                 my_friendly_assert (flags == NO_SPECIAL, 154);
9837                 flags = TYPENAME_FLAG;
9838                 ctor_return_type = TREE_TYPE (dname);
9839                 sfk = sfk_conversion;
9840                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9841                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9842                         == TYPE_DECL))
9843                   name = IDENTIFIER_POINTER (dname);
9844                 else
9845                   name = "<invalid operator>";
9846               }
9847             break;
9848
9849             /* C++ extension */
9850           case SCOPE_REF:
9851             {
9852               /* Perform error checking, and decide on a ctype.  */
9853               tree cname = TREE_OPERAND (decl, 0);
9854               if (cname == NULL_TREE)
9855                 ctype = NULL_TREE;
9856               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9857                 {
9858                   ctype = NULL_TREE;
9859                   in_namespace = TREE_OPERAND (decl, 0);
9860                   TREE_OPERAND (decl, 0) = NULL_TREE;
9861                 }
9862               else if (! is_aggr_type (cname, 1))
9863                 TREE_OPERAND (decl, 0) = NULL_TREE;
9864               /* Must test TREE_OPERAND (decl, 1), in case user gives
9865                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9866               else if (TREE_OPERAND (decl, 1)
9867                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9868                 ctype = cname;
9869               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9870                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9871                 {
9872                   cp_error ("`%T::%D' is not a valid declarator", cname,
9873                             TREE_OPERAND (decl, 1));
9874                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9875                             cname, TREE_OPERAND (decl, 1));
9876                   return void_type_node;
9877                 }
9878               else if (ctype == NULL_TREE)
9879                 ctype = cname;
9880               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9881                 TREE_OPERAND (decl, 0) = ctype;
9882               else
9883                 {
9884                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9885                     {
9886                       cp_error ("type `%T' is not derived from type `%T'",
9887                                 cname, ctype);
9888                       TREE_OPERAND (decl, 0) = NULL_TREE;
9889                     }
9890                   else
9891                     ctype = cname;
9892                 }
9893
9894               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9895                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9896                        == constructor_name_full (ctype))
9897                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9898                           == constructor_name (ctype))))
9899                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9900               next = &TREE_OPERAND (decl, 1);
9901               decl = *next;
9902               if (ctype)
9903                 {
9904                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9905                       && constructor_name (ctype) == decl)
9906                     {
9907                       sfk = sfk_constructor;
9908                       ctor_return_type = ctype;
9909                     }
9910                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9911                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9912                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9913                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9914                     {
9915                       sfk = sfk_destructor;
9916                       ctor_return_type = ctype;
9917                       flags = DTOR_FLAG;
9918                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9919                       next = &TREE_OPERAND (decl, 0);
9920                     }
9921                 }
9922             }
9923             break;
9924
9925           case ERROR_MARK:
9926             next = 0;
9927             break;
9928
9929           case TYPE_DECL:
9930             /* Parse error puts this typespec where
9931                a declarator should go.  */
9932             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9933             if (TREE_TYPE (decl) == current_class_type)
9934               cp_error ("  perhaps you want `%T' for a constructor",
9935                         current_class_name);
9936             dname = DECL_NAME (decl);
9937             name = IDENTIFIER_POINTER (dname);
9938
9939             /* Avoid giving two errors for this.  */
9940             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9941
9942             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9943             *next = dname;
9944             next = 0;
9945             break;
9946
9947           default:
9948             cp_compiler_error ("`%D' as declarator", decl);
9949             return 0; /* We used to do a 155 abort here.  */
9950           }
9951       }
9952   }
9953
9954   /* A function definition's declarator must have the form of
9955      a function declarator.  */
9956
9957   if (funcdef_flag && innermost_code != CALL_EXPR)
9958     return 0;
9959
9960   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9961       && innermost_code != CALL_EXPR
9962       && ! (ctype && declspecs == NULL_TREE))
9963     {
9964       cp_error ("declaration of `%D' as non-function", dname);
9965       return void_type_node;
9966     }
9967
9968   /* Anything declared one level down from the top level
9969      must be one of the parameters of a function
9970      (because the body is at least two levels down).  */
9971
9972   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9973      by not allowing C++ class definitions to specify their parameters
9974      with xdecls (must be spec.d in the parmlist).
9975
9976      Since we now wait to push a class scope until we are sure that
9977      we are in a legitimate method context, we must set oldcname
9978      explicitly (since current_class_name is not yet alive).
9979
9980      We also want to avoid calling this a PARM if it is in a namespace.  */
9981
9982   if (decl_context == NORMAL && !toplevel_bindings_p ())
9983     {
9984       struct binding_level *b = current_binding_level;
9985       current_binding_level = b->level_chain;
9986       if (current_binding_level != 0 && toplevel_bindings_p ())
9987         decl_context = PARM;
9988       current_binding_level = b;
9989     }
9990
9991   if (name == NULL)
9992     name = decl_context == PARM ? "parameter" : "type name";
9993
9994   /* Look through the decl specs and record which ones appear.
9995      Some typespecs are defined as built-in typenames.
9996      Others, the ones that are modifiers of other types,
9997      are represented by bits in SPECBITS: set the bits for
9998      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9999
10000      If there is a typedef name or a type, store the type in TYPE.
10001      This includes builtin typedefs such as `int'.
10002
10003      Set EXPLICIT_INT if the type is `int' or `char' and did not
10004      come from a user typedef.
10005
10006      Set LONGLONG if `long' is mentioned twice.
10007
10008      For C++, constructors and destructors have their own fast treatment.  */
10009
10010   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10011     {
10012       register int i;
10013       register tree id;
10014
10015       /* Certain parse errors slip through.  For example,
10016          `int class;' is not caught by the parser. Try
10017          weakly to recover here.  */
10018       if (TREE_CODE (spec) != TREE_LIST)
10019         return 0;
10020
10021       id = TREE_VALUE (spec);
10022
10023       if (TREE_CODE (id) == IDENTIFIER_NODE)
10024         {
10025           if (id == ridpointers[(int) RID_INT]
10026               || id == ridpointers[(int) RID_CHAR]
10027               || id == ridpointers[(int) RID_BOOL]
10028               || id == ridpointers[(int) RID_WCHAR])
10029             {
10030               if (type)
10031                 {
10032                   if (id == ridpointers[(int) RID_BOOL])
10033                     error ("`bool' is now a keyword");
10034                   else
10035                     cp_error ("extraneous `%T' ignored", id);
10036                 }
10037               else
10038                 {
10039                   if (id == ridpointers[(int) RID_INT])
10040                     explicit_int = 1;
10041                   else if (id == ridpointers[(int) RID_CHAR])
10042                     explicit_char = 1;
10043                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10044                 }
10045               goto found;
10046             }
10047           /* C++ aggregate types.  */
10048           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10049             {
10050               if (type)
10051                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10052               else
10053                 type = IDENTIFIER_TYPE_VALUE (id);
10054               goto found;
10055             }
10056
10057           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10058             {
10059               if (ridpointers[i] == id)
10060                 {
10061                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10062                     {
10063                       if (pedantic && ! in_system_header && warn_long_long)
10064                         pedwarn ("ISO C++ does not support `long long'");
10065                       if (longlong)
10066                         error ("`long long long' is too long for GCC");
10067                       else
10068                         longlong = 1;
10069                     }
10070                   else if (RIDBIT_SETP (i, specbits))
10071                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10072                   RIDBIT_SET (i, specbits);
10073                   goto found;
10074                 }
10075             }
10076         }
10077       /* C++ aggregate types.  */
10078       else if (TREE_CODE (id) == TYPE_DECL)
10079         {
10080           if (type)
10081             cp_error ("multiple declarations `%T' and `%T'", type,
10082                       TREE_TYPE (id));
10083           else
10084             {
10085               type = TREE_TYPE (id);
10086               TREE_VALUE (spec) = type;
10087             }
10088           goto found;
10089         }
10090       if (type)
10091         error ("two or more data types in declaration of `%s'", name);
10092       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10093         {
10094           register tree t = lookup_name (id, 1);
10095           if (!t || TREE_CODE (t) != TYPE_DECL)
10096             error ("`%s' fails to be a typedef or built in type",
10097                    IDENTIFIER_POINTER (id));
10098           else
10099             {
10100               type = TREE_TYPE (t);
10101 #if 0
10102               /* See the code below that used this.  */
10103               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10104 #endif
10105               typedef_decl = t;
10106             }
10107         }
10108       else if (id != error_mark_node)
10109         /* Can't change CLASS nodes into RECORD nodes here!  */
10110         type = id;
10111
10112     found: ;
10113     }
10114
10115   typedef_type = type;
10116
10117   /* No type at all: default to `int', and set DEFAULTED_INT
10118      because it was not a user-defined typedef.  */
10119
10120   if (type == NULL_TREE
10121       && (RIDBIT_SETP (RID_SIGNED, specbits)
10122           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10123           || RIDBIT_SETP (RID_LONG, specbits)
10124           || RIDBIT_SETP (RID_SHORT, specbits)))
10125     {
10126       /* These imply 'int'.  */
10127       type = integer_type_node;
10128       defaulted_int = 1;
10129     }
10130
10131   if (sfk != sfk_none)
10132     type = check_special_function_return_type (sfk, type,
10133                                                ctor_return_type,
10134                                                ctor_return_type);
10135   else if (type == NULL_TREE)
10136     {
10137       int is_main;
10138
10139       explicit_int = -1;
10140
10141           /* We handle `main' specially here, because 'main () { }' is so
10142              common.  With no options, it is allowed.  With -Wreturn-type,
10143              it is a warning.  It is only an error with -pedantic-errors.  */
10144       is_main = (funcdef_flag
10145                  && MAIN_NAME_P (dname)
10146                  && ctype == NULL_TREE
10147                  && in_namespace == NULL_TREE
10148                  && current_namespace == global_namespace);
10149
10150       if (in_system_header || flag_ms_extensions)
10151         /* Allow it, sigh.  */;
10152       else if (pedantic || ! is_main)
10153         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10154                     name);
10155       else if (warn_return_type)
10156         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10157                     name);
10158
10159       type = integer_type_node;
10160     }
10161
10162   ctype = NULL_TREE;
10163
10164   /* Now process the modifiers that were specified
10165      and check for invalid combinations.  */
10166
10167   /* Long double is a special combination.  */
10168
10169   if (RIDBIT_SETP (RID_LONG, specbits)
10170       && TYPE_MAIN_VARIANT (type) == double_type_node)
10171     {
10172       RIDBIT_RESET (RID_LONG, specbits);
10173       type = build_qualified_type (long_double_type_node,
10174                                    CP_TYPE_QUALS (type));
10175     }
10176
10177   /* Check all other uses of type modifiers.  */
10178
10179   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10180       || RIDBIT_SETP (RID_SIGNED, specbits)
10181       || RIDBIT_SETP (RID_LONG, specbits)
10182       || RIDBIT_SETP (RID_SHORT, specbits))
10183     {
10184       int ok = 0;
10185
10186       if (TREE_CODE (type) == REAL_TYPE)
10187         error ("short, signed or unsigned invalid for `%s'", name);
10188       else if (TREE_CODE (type) != INTEGER_TYPE)
10189         error ("long, short, signed or unsigned invalid for `%s'", name);
10190       else if (RIDBIT_SETP (RID_LONG, specbits)
10191                && RIDBIT_SETP (RID_SHORT, specbits))
10192         error ("long and short specified together for `%s'", name);
10193       else if ((RIDBIT_SETP (RID_LONG, specbits)
10194                 || RIDBIT_SETP (RID_SHORT, specbits))
10195                && explicit_char)
10196         error ("long or short specified with char for `%s'", name);
10197       else if ((RIDBIT_SETP (RID_LONG, specbits)
10198                 || RIDBIT_SETP (RID_SHORT, specbits))
10199                && TREE_CODE (type) == REAL_TYPE)
10200         error ("long or short specified with floating type for `%s'", name);
10201       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10202                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10203         error ("signed and unsigned given together for `%s'", name);
10204       else
10205         {
10206           ok = 1;
10207           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10208             {
10209               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10210                        name);
10211               if (flag_pedantic_errors)
10212                 ok = 0;
10213             }
10214         }
10215
10216       /* Discard the type modifiers if they are invalid.  */
10217       if (! ok)
10218         {
10219           RIDBIT_RESET (RID_UNSIGNED, specbits);
10220           RIDBIT_RESET (RID_SIGNED, specbits);
10221           RIDBIT_RESET (RID_LONG, specbits);
10222           RIDBIT_RESET (RID_SHORT, specbits);
10223           longlong = 0;
10224         }
10225     }
10226
10227   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10228       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10229     {
10230       error ("complex invalid for `%s'", name);
10231       RIDBIT_RESET (RID_COMPLEX, specbits);
10232     }
10233
10234   /* Decide whether an integer type is signed or not.
10235      Optionally treat bitfields as signed by default.  */
10236   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10237       /* [class.bit]
10238
10239          It is implementation-defined whether a plain (neither
10240          explicitly signed or unsigned) char, short, int, or long
10241          bit-field is signed or unsigned.
10242
10243          Naturally, we extend this to long long as well.  Note that
10244          this does not include wchar_t.  */
10245       || (bitfield && !flag_signed_bitfields
10246           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10247           /* A typedef for plain `int' without `signed' can be
10248              controlled just like plain `int', but a typedef for
10249              `signed int' cannot be so controlled.  */
10250           && !(typedef_decl
10251                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10252           && (TREE_CODE (type) == INTEGER_TYPE
10253               || TREE_CODE (type) == CHAR_TYPE)
10254           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10255     {
10256       if (longlong)
10257         type = long_long_unsigned_type_node;
10258       else if (RIDBIT_SETP (RID_LONG, specbits))
10259         type = long_unsigned_type_node;
10260       else if (RIDBIT_SETP (RID_SHORT, specbits))
10261         type = short_unsigned_type_node;
10262       else if (type == char_type_node)
10263         type = unsigned_char_type_node;
10264       else if (typedef_decl)
10265         type = unsigned_type (type);
10266       else
10267         type = unsigned_type_node;
10268     }
10269   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10270            && type == char_type_node)
10271     type = signed_char_type_node;
10272   else if (longlong)
10273     type = long_long_integer_type_node;
10274   else if (RIDBIT_SETP (RID_LONG, specbits))
10275     type = long_integer_type_node;
10276   else if (RIDBIT_SETP (RID_SHORT, specbits))
10277     type = short_integer_type_node;
10278
10279   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10280     {
10281       /* If we just have "complex", it is equivalent to
10282          "complex double", but if any modifiers at all are specified it is
10283          the complex form of TYPE.  E.g, "complex short" is
10284          "complex short int".  */
10285
10286       if (defaulted_int && ! longlong
10287           && ! (RIDBIT_SETP (RID_LONG, specbits)
10288                 || RIDBIT_SETP (RID_SHORT, specbits)
10289                 || RIDBIT_SETP (RID_SIGNED, specbits)
10290                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10291         type = complex_double_type_node;
10292       else if (type == integer_type_node)
10293         type = complex_integer_type_node;
10294       else if (type == float_type_node)
10295         type = complex_float_type_node;
10296       else if (type == double_type_node)
10297         type = complex_double_type_node;
10298       else if (type == long_double_type_node)
10299         type = complex_long_double_type_node;
10300       else
10301         type = build_complex_type (type);
10302     }
10303
10304   if (sfk == sfk_conversion
10305       && (RIDBIT_SETP (RID_CONST, specbits)
10306           || RIDBIT_SETP (RID_VOLATILE, specbits)
10307           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10308     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10309               ctor_return_type);
10310
10311   /* Set CONSTP if this declaration is `const', whether by
10312      explicit specification or via a typedef.
10313      Likewise for VOLATILEP.  */
10314
10315   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10316   restrictp =
10317     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10318   volatilep =
10319     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10320   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10321                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10322                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10323   type = cp_build_qualified_type (type, type_quals);
10324   staticp = 0;
10325   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10326   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10327   RIDBIT_RESET (RID_VIRTUAL, specbits);
10328   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10329   RIDBIT_RESET (RID_EXPLICIT, specbits);
10330
10331   if (RIDBIT_SETP (RID_STATIC, specbits))
10332     staticp = 1 + (decl_context == FIELD);
10333
10334   if (virtualp && staticp == 2)
10335     {
10336       cp_error ("member `%D' cannot be declared both virtual and static",
10337                 dname);
10338       staticp = 0;
10339     }
10340   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10341   RIDBIT_RESET (RID_FRIEND, specbits);
10342
10343   /* Warn if two storage classes are given. Default to `auto'.  */
10344
10345   if (RIDBIT_ANY_SET (specbits))
10346     {
10347       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10348       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10349       if (decl_context == PARM && nclasses > 0)
10350         error ("storage class specifiers invalid in parameter declarations");
10351       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10352         {
10353           if (decl_context == PARM)
10354             error ("typedef declaration invalid in parameter declaration");
10355           nclasses++;
10356         }
10357       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10358       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10359     }
10360
10361   /* Give error if `virtual' is used outside of class declaration.  */
10362   if (virtualp
10363       && (current_class_name == NULL_TREE || decl_context != FIELD))
10364     {
10365       error ("virtual outside class declaration");
10366       virtualp = 0;
10367     }
10368
10369   /* Static anonymous unions are dealt with here.  */
10370   if (staticp && decl_context == TYPENAME
10371       && TREE_CODE (declspecs) == TREE_LIST
10372       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10373     decl_context = FIELD;
10374
10375   /* Warn about storage classes that are invalid for certain
10376      kinds of declarations (parameters, typenames, etc.).  */
10377
10378   if (nclasses > 1)
10379     error ("multiple storage classes in declaration of `%s'", name);
10380   else if (decl_context != NORMAL && nclasses > 0)
10381     {
10382       if ((decl_context == PARM || decl_context == CATCHPARM)
10383           && (RIDBIT_SETP (RID_REGISTER, specbits)
10384               || RIDBIT_SETP (RID_AUTO, specbits)))
10385         ;
10386       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10387         ;
10388       else if (decl_context == FIELD
10389                /* C++ allows static class elements  */
10390                && RIDBIT_SETP (RID_STATIC, specbits))
10391         /* C++ also allows inlines and signed and unsigned elements,
10392            but in those cases we don't come in here.  */
10393         ;
10394       else
10395         {
10396           if (decl_context == FIELD)
10397             {
10398               tree tmp = NULL_TREE;
10399               register int op = 0;
10400
10401               if (declarator)
10402                 {
10403                   /* Avoid trying to get an operand off an identifier node.  */
10404                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10405                     tmp = declarator;
10406                   else
10407                     tmp = TREE_OPERAND (declarator, 0);
10408                   op = IDENTIFIER_OPNAME_P (tmp);
10409                   if (IDENTIFIER_TYPENAME_P (tmp))
10410                     {
10411                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10412                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10413                               == TYPE_DECL))
10414                         name = IDENTIFIER_POINTER (tmp);
10415                       else
10416                         name = "<invalid operator>";
10417                     }
10418                 }
10419               error ("storage class specified for %s `%s'",
10420                      op ? "member operator" : "field",
10421                      name);
10422             }
10423           else
10424             {
10425               if (decl_context == PARM || decl_context == CATCHPARM)
10426                 error ("storage class specified for parameter `%s'", name);
10427               else
10428                 error ("storage class specified for typename");
10429             }
10430           RIDBIT_RESET (RID_REGISTER, specbits);
10431           RIDBIT_RESET (RID_AUTO, specbits);
10432           RIDBIT_RESET (RID_EXTERN, specbits);
10433         }
10434     }
10435   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10436     {
10437       if (toplevel_bindings_p ())
10438         {
10439           /* It's common practice (and completely valid) to have a const
10440              be initialized and declared extern.  */
10441           if (!(type_quals & TYPE_QUAL_CONST))
10442             warning ("`%s' initialized and declared `extern'", name);
10443         }
10444       else
10445         error ("`%s' has both `extern' and initializer", name);
10446     }
10447   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10448            && ! toplevel_bindings_p ())
10449     error ("nested function `%s' declared `extern'", name);
10450   else if (toplevel_bindings_p ())
10451     {
10452       if (RIDBIT_SETP (RID_AUTO, specbits))
10453         error ("top-level declaration of `%s' specifies `auto'", name);
10454     }
10455
10456   if (nclasses > 0 && friendp)
10457     error ("storage class specifiers invalid in friend function declarations");
10458
10459   /* Now figure out the structure of the declarator proper.
10460      Descend through it, creating more complex types, until we reach
10461      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10462
10463   inner_attrs = NULL_TREE;
10464   ignore_attrs = 0;
10465
10466   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10467          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10468     {
10469       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10470          an INDIRECT_REF (for *...),
10471          a CALL_EXPR (for ...(...)),
10472          an identifier (for the name being declared)
10473          or a null pointer (for the place in an absolute declarator
10474          where the name was omitted).
10475          For the last two cases, we have just exited the loop.
10476
10477          For C++ it could also be
10478          a SCOPE_REF (for class :: ...).  In this case, we have converted
10479          sensible names to types, and those are the values we use to
10480          qualify the member name.
10481          an ADDR_EXPR (for &...),
10482          a BIT_NOT_EXPR (for destructors)
10483
10484          At this point, TYPE is the type of elements of an array,
10485          or for a function to return, or for a pointer to point to.
10486          After this sequence of ifs, TYPE is the type of the
10487          array or function or pointer, and DECLARATOR has had its
10488          outermost layer removed.  */
10489
10490       if (type == error_mark_node)
10491         {
10492           if (TREE_CODE (declarator) == SCOPE_REF)
10493             declarator = TREE_OPERAND (declarator, 1);
10494           else
10495             declarator = TREE_OPERAND (declarator, 0);
10496           continue;
10497         }
10498       if (quals != NULL_TREE
10499           && (declarator == NULL_TREE
10500               || TREE_CODE (declarator) != SCOPE_REF))
10501         {
10502           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10503             ctype = TYPE_METHOD_BASETYPE (type);
10504           if (ctype != NULL_TREE)
10505             {
10506               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10507               grok_method_quals (ctype, dummy, quals);
10508               type = TREE_TYPE (dummy);
10509               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10510               quals = NULL_TREE;
10511             }
10512         }
10513
10514       /* See the comment for the TREE_LIST case, below.  */
10515       if (ignore_attrs)
10516         ignore_attrs = 0;
10517       else if (inner_attrs)
10518         {
10519           decl_attributes (type, inner_attrs, NULL_TREE);
10520           inner_attrs = NULL_TREE;
10521         }
10522
10523       switch (TREE_CODE (declarator))
10524         {
10525         case TREE_LIST:
10526           {
10527             /* We encode a declarator with embedded attributes using
10528                a TREE_LIST.  The attributes apply to the declarator
10529                directly inside them, so we have to skip an iteration
10530                before applying them to the type.  If the declarator just
10531                inside is the declarator-id, we apply the attrs to the
10532                decl itself.  */
10533             inner_attrs = TREE_PURPOSE (declarator);
10534             ignore_attrs = 1;
10535             declarator = TREE_VALUE (declarator);
10536           }
10537           break;
10538
10539         case ARRAY_REF:
10540           {
10541             register tree size;
10542
10543             size = TREE_OPERAND (declarator, 1);
10544
10545             /* VC++ spells a zero-sized array with [].  */
10546             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10547                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10548               size = integer_zero_node;
10549
10550             declarator = TREE_OPERAND (declarator, 0);
10551
10552             type = create_array_type_for_decl (dname, type, size);
10553
10554             /* VLAs never work as fields. */
10555             if (decl_context == FIELD && !processing_template_decl
10556                 && TREE_CODE (type) == ARRAY_TYPE
10557                 && TYPE_DOMAIN (type) != NULL_TREE
10558                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10559               {
10560                 cp_error ("size of member `%D' is not constant", dname);
10561                 /* Proceed with arbitrary constant size, so that offset
10562                    computations don't get confused. */
10563                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10564                                                    integer_one_node);
10565               }
10566
10567             ctype = NULL_TREE;
10568           }
10569           break;
10570
10571         case CALL_EXPR:
10572           {
10573             tree arg_types;
10574             int funcdecl_p;
10575             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10576             tree inner_decl = TREE_OPERAND (declarator, 0);
10577
10578             /* Declaring a function type.
10579                Make sure we have a valid type for the function to return.  */
10580
10581             /* We now know that the TYPE_QUALS don't apply to the
10582                decl, but to its return type.  */
10583             type_quals = TYPE_UNQUALIFIED;
10584
10585             /* Warn about some types functions can't return.  */
10586
10587             if (TREE_CODE (type) == FUNCTION_TYPE)
10588               {
10589                 error ("`%s' declared as function returning a function", name);
10590                 type = integer_type_node;
10591               }
10592             if (TREE_CODE (type) == ARRAY_TYPE)
10593               {
10594                 error ("`%s' declared as function returning an array", name);
10595                 type = integer_type_node;
10596               }
10597
10598             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10599               inner_decl = TREE_OPERAND (inner_decl, 1);
10600
10601             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10602               inner_decl = dname;
10603
10604             /* Pick up type qualifiers which should be applied to `this'.  */
10605             quals = CALL_DECLARATOR_QUALS (declarator);
10606
10607             /* Pick up the exception specifications.  */
10608             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10609
10610             /* Say it's a definition only for the CALL_EXPR
10611                closest to the identifier.  */
10612             funcdecl_p
10613               = inner_decl
10614               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10615                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10616                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10617
10618             if (ctype == NULL_TREE
10619                 && decl_context == FIELD
10620                 && funcdecl_p
10621                 && (friendp == 0 || dname == current_class_name))
10622               ctype = current_class_type;
10623
10624             if (ctype && sfk == sfk_conversion)
10625               TYPE_HAS_CONVERSION (ctype) = 1;
10626             if (ctype && constructor_name (ctype) == dname)
10627               {
10628                 /* We are within a class's scope. If our declarator name
10629                    is the same as the class name, and we are defining
10630                    a function, then it is a constructor/destructor, and
10631                    therefore returns a void type.  */
10632
10633                 if (flags == DTOR_FLAG)
10634                   {
10635                     /* ISO C++ 12.4/2.  A destructor may not be
10636                        declared const or volatile.  A destructor may
10637                        not be static.  */
10638                     if (staticp == 2)
10639                       error ("destructor cannot be static member function");
10640                     if (quals)
10641                       {
10642                         cp_error ("destructors may not be `%s'",
10643                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10644                         quals = NULL_TREE;
10645                       }
10646                     if (decl_context == FIELD)
10647                       {
10648                         if (! member_function_or_else (ctype,
10649                                                        current_class_type,
10650                                                        flags))
10651                           return void_type_node;
10652                       }
10653                   }
10654                 else            /* It's a constructor.  */
10655                   {
10656                     if (explicitp == 1)
10657                       explicitp = 2;
10658                     /* ISO C++ 12.1.  A constructor may not be
10659                        declared const or volatile.  A constructor may
10660                        not be virtual.  A constructor may not be
10661                        static.  */
10662                     if (staticp == 2)
10663                       error ("constructor cannot be static member function");
10664                     if (virtualp)
10665                       {
10666                         pedwarn ("constructors cannot be declared virtual");
10667                         virtualp = 0;
10668                       }
10669                     if (quals)
10670                       {
10671                         cp_error ("constructors may not be `%s'",
10672                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10673                         quals = NULL_TREE;
10674                       }
10675                     {
10676                       RID_BIT_TYPE tmp_bits;
10677                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10678                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10679                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10680                       if (RIDBIT_ANY_SET (tmp_bits))
10681                         error ("return value type specifier for constructor ignored");
10682                     }
10683                     if (decl_context == FIELD)
10684                       {
10685                         if (! member_function_or_else (ctype,
10686                                                        current_class_type,
10687                                                        flags))
10688                           return void_type_node;
10689                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10690                         if (sfk != sfk_constructor)
10691                           return NULL_TREE;
10692                       }
10693                   }
10694                 if (decl_context == FIELD)
10695                   staticp = 0;
10696               }
10697             else if (friendp)
10698               {
10699                 if (initialized)
10700                   error ("can't initialize friend function `%s'", name);
10701                 if (virtualp)
10702                   {
10703                     /* Cannot be both friend and virtual.  */
10704                     error ("virtual functions cannot be friends");
10705                     RIDBIT_RESET (RID_FRIEND, specbits);
10706                     friendp = 0;
10707                   }
10708                 if (decl_context == NORMAL)
10709                   error ("friend declaration not in class definition");
10710                 if (current_function_decl && funcdef_flag)
10711                   cp_error ("can't define friend function `%s' in a local class definition",
10712                             name);
10713               }
10714
10715             /* Construct the function type and go to the next
10716                inner layer of declarator.  */
10717
10718             declarator = TREE_OPERAND (declarator, 0);
10719
10720             /* FIXME: This is where default args should be fully
10721                processed.  */
10722
10723             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10724
10725             if (declarator && flags == DTOR_FLAG)
10726               {
10727                 /* A destructor declared in the body of a class will
10728                    be represented as a BIT_NOT_EXPR.  But, we just
10729                    want the underlying IDENTIFIER.  */
10730                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10731                   declarator = TREE_OPERAND (declarator, 0);
10732
10733                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10734                   arg_types = void_list_node;
10735                 else if (arg_types == NULL_TREE
10736                          || arg_types != void_list_node)
10737                   {
10738                     cp_error ("destructors may not have parameters");
10739                     arg_types = void_list_node;
10740                     last_function_parms = NULL_TREE;
10741                   }
10742               }
10743
10744             /* ANSI says that `const int foo ();'
10745                does not make the function foo const.  */
10746             type = build_function_type (type, arg_types);
10747
10748             {
10749               tree t;
10750               for (t = arg_types; t; t = TREE_CHAIN (t))
10751                 if (TREE_PURPOSE (t)
10752                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10753                   {
10754                     add_defarg_fn (type);
10755                     break;
10756                   }
10757             }
10758           }
10759           break;
10760
10761         case ADDR_EXPR:
10762         case INDIRECT_REF:
10763           /* Filter out pointers-to-references and references-to-references.
10764              We can get these if a TYPE_DECL is used.  */
10765
10766           if (TREE_CODE (type) == REFERENCE_TYPE)
10767             {
10768               error ("cannot declare %s to references",
10769                      TREE_CODE (declarator) == ADDR_EXPR
10770                      ? "references" : "pointers");
10771               declarator = TREE_OPERAND (declarator, 0);
10772               continue;
10773             }
10774
10775           if (TREE_CODE (type) == OFFSET_TYPE
10776               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10777                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10778             {
10779               cp_error ("cannot declare pointer to `%#T' member",
10780                         TREE_TYPE (type));
10781               type = TREE_TYPE (type);
10782             }
10783
10784           /* Merge any constancy or volatility into the target type
10785              for the pointer.  */
10786
10787           /* We now know that the TYPE_QUALS don't apply to the decl,
10788              but to the target of the pointer.  */
10789           type_quals = TYPE_UNQUALIFIED;
10790
10791           if (TREE_CODE (declarator) == ADDR_EXPR)
10792             {
10793               if (TREE_CODE (type) == VOID_TYPE)
10794                 error ("invalid type: `void &'");
10795               else
10796                 type = build_reference_type (type);
10797             }
10798           else if (TREE_CODE (type) == METHOD_TYPE)
10799             type = build_ptrmemfunc_type (build_pointer_type (type));
10800           else
10801             type = build_pointer_type (type);
10802
10803           /* Process a list of type modifier keywords (such as
10804              const or volatile) that were given inside the `*' or `&'.  */
10805
10806           if (TREE_TYPE (declarator))
10807             {
10808               register tree typemodlist;
10809               int erred = 0;
10810
10811               constp = 0;
10812               volatilep = 0;
10813               restrictp = 0;
10814               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10815                    typemodlist = TREE_CHAIN (typemodlist))
10816                 {
10817                   tree qualifier = TREE_VALUE (typemodlist);
10818
10819                   if (qualifier == ridpointers[(int) RID_CONST])
10820                     constp++;
10821                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10822                     volatilep++;
10823                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10824                     restrictp++;
10825                   else if (!erred)
10826                     {
10827                       erred = 1;
10828                       error ("invalid type modifier within pointer declarator");
10829                     }
10830                 }
10831               if (constp > 1)
10832                 pedwarn ("duplicate `const'");
10833               if (volatilep > 1)
10834                 pedwarn ("duplicate `volatile'");
10835               if (restrictp > 1)
10836                 pedwarn ("duplicate `restrict'");
10837
10838               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10839                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10840                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10841               if (TREE_CODE (declarator) == ADDR_EXPR
10842                   && (constp || volatilep))
10843                 {
10844                   if (constp)
10845                     pedwarn ("discarding `const' applied to a reference");
10846                   if (volatilep)
10847                     pedwarn ("discarding `volatile' applied to a reference");
10848                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10849                 }
10850               type = cp_build_qualified_type (type, type_quals);
10851             }
10852           declarator = TREE_OPERAND (declarator, 0);
10853           ctype = NULL_TREE;
10854           break;
10855
10856         case SCOPE_REF:
10857           {
10858             /* We have converted type names to NULL_TREE if the
10859                name was bogus, or to a _TYPE node, if not.
10860
10861                The variable CTYPE holds the type we will ultimately
10862                resolve to.  The code here just needs to build
10863                up appropriate member types.  */
10864             tree sname = TREE_OPERAND (declarator, 1);
10865             tree t;
10866
10867             /* Destructors can have their visibilities changed as well.  */
10868             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10869               sname = TREE_OPERAND (sname, 0);
10870
10871             if (TREE_COMPLEXITY (declarator) == 0)
10872               /* This needs to be here, in case we are called
10873                  multiple times.  */ ;
10874             else if (TREE_COMPLEXITY (declarator) == -1)
10875               /* Namespace member. */
10876               pop_decl_namespace ();
10877             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10878               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10879             else if (! IS_AGGR_TYPE_CODE
10880                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10881               ;
10882             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10883               {
10884                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10885                    that refer to ctype.  They couldn't be resolved earlier
10886                    because we hadn't pushed into the class yet.
10887                    Example: resolve 'B<T>::type' in
10888                    'B<typename B<T>::type> B<T>::f () { }'.  */
10889                 if (current_template_parms
10890                     && uses_template_parms (type)
10891                     && uses_template_parms (current_class_type))
10892                   {
10893                     tree args = current_template_args ();
10894                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10895                   }
10896
10897                 /* This pop_nested_class corresponds to the
10898                    push_nested_class used to push into class scope for
10899                    parsing the argument list of a function decl, in
10900                    qualified_id.  */
10901                 pop_nested_class ();
10902                 TREE_COMPLEXITY (declarator) = current_class_depth;
10903               }
10904             else
10905               my_friendly_abort (16);
10906
10907             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10908               {
10909                 /* We had a reference to a global decl, or
10910                    perhaps we were given a non-aggregate typedef,
10911                    in which case we cleared this out, and should just
10912                    keep going as though it wasn't there.  */
10913                 declarator = sname;
10914                 continue;
10915               }
10916             ctype = TREE_OPERAND (declarator, 0);
10917
10918             t = ctype;
10919             while (t != NULL_TREE && CLASS_TYPE_P (t))
10920               {
10921                 /* You're supposed to have one `template <...>'
10922                    for every template class, but you don't need one
10923                    for a full specialization.  For example:
10924
10925                      template <class T> struct S{};
10926                      template <> struct S<int> { void f(); };
10927                      void S<int>::f () {}
10928
10929                    is correct; there shouldn't be a `template <>' for
10930                    the definition of `S<int>::f'.  */
10931                 if (CLASSTYPE_TEMPLATE_INFO (t)
10932                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10933                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10934                   template_count += 1;
10935
10936                 t = TYPE_MAIN_DECL (t);
10937                 if (DECL_LANG_SPECIFIC (t))
10938                   t = DECL_CONTEXT (t);
10939                 else
10940                   t = NULL_TREE;
10941               }
10942
10943             if (sname == NULL_TREE)
10944               goto done_scoping;
10945
10946             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10947               {
10948                 /* This is the `standard' use of the scoping operator:
10949                    basetype :: member .  */
10950
10951                 if (ctype == current_class_type)
10952                   {
10953                     /* class A {
10954                          void A::f ();
10955                        };
10956
10957                        Is this ill-formed?  */
10958
10959                     if (pedantic)
10960                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10961                                   ctype, name);
10962                   }
10963                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10964                   {
10965                     if (current_class_type == NULL_TREE
10966                         || friendp)
10967                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10968                                                       TYPE_ARG_TYPES (type));
10969                     else
10970                       {
10971                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10972                                   ctype, name, current_class_type);
10973                         return void_type_node;
10974                       }
10975                   }
10976                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10977                          || COMPLETE_TYPE_P (complete_type (ctype)))
10978                   {
10979                     /* Have to move this code elsewhere in this function.
10980                        this code is used for i.e., typedef int A::M; M *pm;
10981
10982                        It is?  How? jason 10/2/94 */
10983
10984                     if (current_class_type)
10985                       {
10986                         cp_error ("cannot declare member `%T::%s' within `%T'",
10987                                   ctype, name, current_class_type);
10988                         return void_type_node;
10989                       }
10990                     type = build_offset_type (ctype, type);
10991                   }
10992                 else if (uses_template_parms (ctype))
10993                   {
10994                     if (TREE_CODE (type) == FUNCTION_TYPE)
10995                       type
10996                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10997                                                    TYPE_ARG_TYPES (type));
10998                   }
10999                 else
11000                   {
11001                     cp_error ("structure `%T' not yet defined", ctype);
11002                     return error_mark_node;
11003                   }
11004
11005                 declarator = sname;
11006               }
11007             else if (TREE_CODE (sname) == SCOPE_REF)
11008               my_friendly_abort (17);
11009             else
11010               {
11011               done_scoping:
11012                 declarator = TREE_OPERAND (declarator, 1);
11013                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11014                   /* In this case, we will deal with it later.  */
11015                   ;
11016                 else
11017                   {
11018                     if (TREE_CODE (type) == FUNCTION_TYPE)
11019                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11020                                                       TYPE_ARG_TYPES (type));
11021                     else
11022                       type = build_offset_type (ctype, type);
11023                   }
11024               }
11025           }
11026           break;
11027
11028         case BIT_NOT_EXPR:
11029           declarator = TREE_OPERAND (declarator, 0);
11030           break;
11031
11032         case RECORD_TYPE:
11033         case UNION_TYPE:
11034         case ENUMERAL_TYPE:
11035           declarator = NULL_TREE;
11036           break;
11037
11038         case ERROR_MARK:
11039           declarator = NULL_TREE;
11040           break;
11041
11042         default:
11043           my_friendly_abort (158);
11044         }
11045     }
11046
11047   /* See the comment for the TREE_LIST case, above.  */
11048   if (inner_attrs)
11049     {
11050       if (! ignore_attrs)
11051         decl_attributes (type, inner_attrs, NULL_TREE);
11052       else if (attrlist)
11053         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11054       else
11055         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11056     }
11057
11058   /* Now TYPE has the actual type.  */
11059
11060   if (explicitp == 1 || (explicitp && friendp))
11061     {
11062       /* [dcl.fct.spec] The explicit specifier shall only be used in
11063          declarations of constructors within a class definition.  */
11064       error ("only declarations of constructors can be `explicit'");
11065       explicitp = 0;
11066     }
11067
11068   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11069     {
11070       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11071         {
11072           error ("non-member `%s' cannot be declared `mutable'", name);
11073           RIDBIT_RESET (RID_MUTABLE, specbits);
11074         }
11075       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11076         {
11077           error ("non-object member `%s' cannot be declared `mutable'", name);
11078           RIDBIT_RESET (RID_MUTABLE, specbits);
11079         }
11080       else if (TREE_CODE (type) == FUNCTION_TYPE
11081                || TREE_CODE (type) == METHOD_TYPE)
11082         {
11083           error ("function `%s' cannot be declared `mutable'", name);
11084           RIDBIT_RESET (RID_MUTABLE, specbits);
11085         }
11086       else if (staticp)
11087         {
11088           error ("static `%s' cannot be declared `mutable'", name);
11089           RIDBIT_RESET (RID_MUTABLE, specbits);
11090         }
11091       else if (type_quals & TYPE_QUAL_CONST)
11092         {
11093           error ("const `%s' cannot be declared `mutable'", name);
11094           RIDBIT_RESET (RID_MUTABLE, specbits);
11095         }
11096     }
11097
11098   if (declarator == NULL_TREE
11099       || TREE_CODE (declarator) == IDENTIFIER_NODE
11100       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11101           && (TREE_CODE (type) == FUNCTION_TYPE
11102               || TREE_CODE (type) == METHOD_TYPE)))
11103     /* OK */;
11104   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11105     {
11106       cp_error ("template-id `%D' used as a declarator", declarator);
11107       declarator = dname;
11108     }
11109   else
11110     /* Unexpected declarator format.  */
11111     my_friendly_abort (990210);
11112
11113   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11114
11115   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11116     {
11117       tree decl;
11118
11119       /* Note that the grammar rejects storage classes
11120          in typenames, fields or parameters.  */
11121       if (current_lang_name == lang_name_java)
11122         TYPE_FOR_JAVA (type) = 1;
11123
11124       if (decl_context == FIELD)
11125         {
11126           if (declarator == constructor_name (current_class_type))
11127             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11128                         declarator);
11129           decl = build_lang_decl (TYPE_DECL, declarator, type);
11130         }
11131       else
11132         decl = build_decl (TYPE_DECL, declarator, type);
11133
11134       /* If the user declares "typedef struct {...} foo" then the
11135          struct will have an anonymous name.  Fill that name in now.
11136          Nothing can refer to it, so nothing needs know about the name
11137          change.  */
11138       if (type != error_mark_node
11139           && declarator
11140           && TYPE_NAME (type)
11141           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11142           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11143           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11144         {
11145           tree oldname = TYPE_NAME (type);
11146           tree t;
11147
11148           /* Replace the anonymous name with the real name everywhere.  */
11149           lookup_tag_reverse (type, declarator);
11150           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11151             if (TYPE_NAME (t) == oldname)
11152               TYPE_NAME (t) = decl;
11153
11154           if (TYPE_LANG_SPECIFIC (type))
11155             TYPE_WAS_ANONYMOUS (type) = 1;
11156
11157           /* If this is a typedef within a template class, the nested
11158              type is a (non-primary) template.  The name for the
11159              template needs updating as well.  */
11160           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11161             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11162               = TYPE_IDENTIFIER (type);
11163
11164           if (flag_new_abi)
11165             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11166           else
11167             {
11168               /* XXX Temporarily set the scope.
11169                  When returning, start_decl expects it as NULL_TREE,
11170                  and will then then set it using pushdecl. */
11171               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11172               if (current_class_type)
11173                 DECL_CONTEXT (decl) = current_class_type;
11174               else
11175                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11176
11177               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11178               DECL_ASSEMBLER_NAME (decl)
11179                 = get_identifier (build_overload_name (type, 1, 1));
11180               DECL_CONTEXT (decl) = NULL_TREE;
11181             }
11182
11183           /* FIXME remangle member functions; member functions of a
11184              type with external linkage have external linkage.  */
11185         }
11186
11187       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11188         {
11189           cp_error_at ("typedef name may not be class-qualified", decl);
11190           return NULL_TREE;
11191         }
11192       else if (quals)
11193         {
11194           if (ctype == NULL_TREE)
11195             {
11196               if (TREE_CODE (type) != METHOD_TYPE)
11197                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11198               else
11199                 ctype = TYPE_METHOD_BASETYPE (type);
11200             }
11201           if (ctype != NULL_TREE)
11202             grok_method_quals (ctype, decl, quals);
11203         }
11204
11205       if (RIDBIT_SETP (RID_SIGNED, specbits)
11206           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11207         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11208
11209       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11210                       inlinep, friendp, raises != NULL_TREE);
11211
11212       if (initialized)
11213         error ("typedef declaration includes an initializer");
11214
11215       return decl;
11216     }
11217
11218   /* Detect the case of an array type of unspecified size
11219      which came, as such, direct from a typedef name.
11220      We must copy the type, so that each identifier gets
11221      a distinct type, so that each identifier's size can be
11222      controlled separately by its own initializer.  */
11223
11224   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11225       && TYPE_DOMAIN (type) == NULL_TREE)
11226     {
11227       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11228     }
11229
11230   /* If this is a type name (such as, in a cast or sizeof),
11231      compute the type and return it now.  */
11232
11233   if (decl_context == TYPENAME)
11234     {
11235       /* Note that the grammar rejects storage classes
11236          in typenames, fields or parameters.  */
11237       if (type_quals != TYPE_UNQUALIFIED)
11238         type_quals = TYPE_UNQUALIFIED;
11239
11240       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11241       if (friendp)
11242         {
11243           if (type_quals != TYPE_UNQUALIFIED)
11244             {
11245               cp_error ("type qualifiers specified for friend class declaration");
11246               type_quals = TYPE_UNQUALIFIED;
11247             }
11248           if (inlinep)
11249             {
11250               cp_error ("`inline' specified for friend class declaration");
11251               inlinep = 0;
11252             }
11253
11254           /* Only try to do this stuff if we didn't already give up.  */
11255           if (type != integer_type_node)
11256             {
11257               /* A friendly class?  */
11258               if (current_class_type)
11259                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11260               else
11261                 error ("trying to make class `%s' a friend of global scope",
11262                        TYPE_NAME_STRING (type));
11263               type = void_type_node;
11264             }
11265         }
11266       else if (quals)
11267         {
11268           if (ctype == NULL_TREE)
11269             {
11270               if (TREE_CODE (type) != METHOD_TYPE)
11271                 cp_error ("invalid qualifiers on non-member function type");
11272               else
11273                 ctype = TYPE_METHOD_BASETYPE (type);
11274             }
11275           if (ctype)
11276             {
11277               tree dummy = build_decl (TYPE_DECL, declarator, type);
11278               grok_method_quals (ctype, dummy, quals);
11279               type = TREE_TYPE (dummy);
11280             }
11281         }
11282
11283       return type;
11284     }
11285   else if (declarator == NULL_TREE && decl_context != PARM
11286            && decl_context != CATCHPARM
11287            && TREE_CODE (type) != UNION_TYPE
11288            && ! bitfield)
11289     {
11290       cp_error ("abstract declarator `%T' used as declaration", type);
11291       declarator = make_anon_name ();
11292     }
11293
11294   /* `void' at top level (not within pointer)
11295      is allowed only in typedefs or type names.
11296      We don't complain about parms either, but that is because
11297      a better error message can be made later.  */
11298
11299   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11300     {
11301       if (! declarator)
11302         error ("unnamed variable or field declared void");
11303       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11304         {
11305           if (IDENTIFIER_OPNAME_P (declarator))
11306             my_friendly_abort (356);
11307           else
11308             error ("variable or field `%s' declared void", name);
11309         }
11310       else
11311         error ("variable or field declared void");
11312       type = integer_type_node;
11313     }
11314
11315   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11316      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11317
11318   if (decl_context == PARM || decl_context == CATCHPARM)
11319     {
11320       if (ctype || in_namespace)
11321         error ("cannot use `::' in parameter declaration");
11322
11323       /* A parameter declared as an array of T is really a pointer to T.
11324          One declared as a function is really a pointer to a function.
11325          One declared as a member is really a pointer to member.  */
11326
11327       if (TREE_CODE (type) == ARRAY_TYPE)
11328         {
11329           /* Transfer const-ness of array into that of type pointed to.  */
11330           type = build_pointer_type (TREE_TYPE (type));
11331           type_quals = TYPE_UNQUALIFIED;
11332         }
11333       else if (TREE_CODE (type) == FUNCTION_TYPE)
11334         type = build_pointer_type (type);
11335       else if (TREE_CODE (type) == OFFSET_TYPE)
11336         type = build_pointer_type (type);
11337       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11338         {
11339           error ("declaration of `%s' as void", name);
11340           return NULL_TREE;
11341         }
11342     }
11343
11344   {
11345     register tree decl;
11346
11347     if (decl_context == PARM)
11348       {
11349         decl = build_decl (PARM_DECL, declarator, type);
11350
11351         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11352                         inlinep, friendp, raises != NULL_TREE);
11353
11354         /* Compute the type actually passed in the parmlist,
11355            for the case where there is no prototype.
11356            (For example, shorts and chars are passed as ints.)
11357            When there is a prototype, this is overridden later.  */
11358
11359         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11360       }
11361     else if (decl_context == FIELD)
11362       {
11363         if (type == error_mark_node)
11364           {
11365             /* Happens when declaring arrays of sizes which
11366                are error_mark_node, for example.  */
11367             decl = NULL_TREE;
11368           }
11369         else if (in_namespace && !friendp)
11370           {
11371             /* Something like struct S { int N::j; };  */
11372             cp_error ("invalid use of `::'");
11373             decl = NULL_TREE;
11374           }
11375         else if (TREE_CODE (type) == FUNCTION_TYPE)
11376           {
11377             int publicp = 0;
11378             tree function_context;
11379
11380             /* We catch the others as conflicts with the builtin
11381                typedefs.  */
11382             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11383               {
11384                 cp_error ("function `%D' cannot be declared friend",
11385                           declarator);
11386                 friendp = 0;
11387               }
11388
11389             if (friendp == 0)
11390               {
11391                 if (ctype == NULL_TREE)
11392                   ctype = current_class_type;
11393
11394                 if (ctype == NULL_TREE)
11395                   {
11396                     cp_error ("can't make `%D' into a method -- not in a class",
11397                               declarator);
11398                     return void_type_node;
11399                   }
11400
11401                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11402                    ARM 9.5 */
11403                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11404                   {
11405                     cp_error ("function `%D' declared virtual inside a union",
11406                               declarator);
11407                     return void_type_node;
11408                   }
11409
11410                 if (declarator == ansi_opname (NEW_EXPR)
11411                     || declarator == ansi_opname (VEC_NEW_EXPR)
11412                     || declarator == ansi_opname (DELETE_EXPR)
11413                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11414                   {
11415                     if (virtualp)
11416                       {
11417                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11418                                   declarator);
11419                         virtualp = 0;
11420                       }
11421                   }
11422                 else if (staticp < 2)
11423                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11424                                                   TYPE_ARG_TYPES (type));
11425               }
11426
11427             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11428             function_context = (ctype != NULL_TREE) ?
11429               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11430             publicp = (! friendp || ! staticp)
11431               && function_context == NULL_TREE;
11432             decl = grokfndecl (ctype, type,
11433                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11434                                ? declarator : dname,
11435                                declarator,
11436                                virtualp, flags, quals, raises,
11437                                friendp ? -1 : 0, friendp, publicp, inlinep,
11438                                funcdef_flag, template_count, in_namespace);
11439             if (decl == NULL_TREE)
11440               return decl;
11441 #if 0
11442             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11443             /* The decl and setting of decl_machine_attr is also turned off.  */
11444             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11445 #endif
11446
11447             /* [class.conv.ctor]
11448
11449                A constructor declared without the function-specifier
11450                explicit that can be called with a single parameter
11451                specifies a conversion from the type of its first
11452                parameter to the type of its class.  Such a constructor
11453                is called a converting constructor.  */
11454             if (explicitp == 2)
11455               DECL_NONCONVERTING_P (decl) = 1;
11456             else if (DECL_CONSTRUCTOR_P (decl))
11457               {
11458                 /* The constructor can be called with exactly one
11459                    parameter if there is at least one parameter, and
11460                    any subsequent parameters have default arguments.
11461                    We don't look at the first parameter, which is
11462                    really just the `this' parameter for the new
11463                    object.  */
11464                 tree arg_types =
11465                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11466
11467                 /* Skip the `in_chrg' argument too, if present.  */
11468                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11469                   arg_types = TREE_CHAIN (arg_types);
11470
11471                 if (arg_types == void_list_node
11472                     || (arg_types
11473                         && TREE_CHAIN (arg_types)
11474                         && TREE_CHAIN (arg_types) != void_list_node
11475                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11476                   DECL_NONCONVERTING_P (decl) = 1;
11477               }
11478           }
11479         else if (TREE_CODE (type) == METHOD_TYPE)
11480           {
11481             /* We only get here for friend declarations of
11482                members of other classes.  */
11483             /* All method decls are public, so tell grokfndecl to set
11484                TREE_PUBLIC, also.  */
11485             decl = grokfndecl (ctype, type, declarator, declarator,
11486                                virtualp, flags, quals, raises,
11487                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11488                                template_count, in_namespace);
11489             if (decl == NULL_TREE)
11490               return NULL_TREE;
11491           }
11492         else if (!staticp && ! processing_template_decl
11493                  && !COMPLETE_TYPE_P (complete_type (type))
11494                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11495           {
11496             if (declarator)
11497               cp_error ("field `%D' has incomplete type", declarator);
11498             else
11499               cp_error ("name `%T' has incomplete type", type);
11500
11501             /* If we're instantiating a template, tell them which
11502                instantiation made the field's type be incomplete.  */
11503             if (current_class_type
11504                 && TYPE_NAME (current_class_type)
11505                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11506                 && declspecs && TREE_VALUE (declspecs)
11507                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11508               cp_error ("  in instantiation of template `%T'",
11509                         current_class_type);
11510
11511             type = error_mark_node;
11512             decl = NULL_TREE;
11513           }
11514         else
11515           {
11516             if (friendp)
11517               {
11518                 error ("`%s' is neither function nor member function; cannot be declared friend",
11519                        IDENTIFIER_POINTER (declarator));
11520                 friendp = 0;
11521               }
11522             decl = NULL_TREE;
11523           }
11524
11525         if (friendp)
11526           {
11527             /* Friends are treated specially.  */
11528             if (ctype == current_class_type)
11529               warning ("member functions are implicitly friends of their class");
11530             else
11531               {
11532                 tree t = NULL_TREE;
11533                 if (decl && DECL_NAME (decl))
11534                   {
11535                     if (template_class_depth (current_class_type) == 0)
11536                       {
11537                         decl
11538                           = check_explicit_specialization
11539                           (declarator, decl,
11540                            template_count, 2 * (funcdef_flag != 0) + 4);
11541                         if (decl == error_mark_node)
11542                           return error_mark_node;
11543                       }
11544
11545                     t = do_friend (ctype, declarator, decl,
11546                                    last_function_parms, attrlist, flags, quals,
11547                                    funcdef_flag);
11548                   }
11549                 if (t && funcdef_flag)
11550                   return t;
11551
11552                 return void_type_node;
11553               }
11554           }
11555
11556         /* Structure field.  It may not be a function, except for C++ */
11557
11558         if (decl == NULL_TREE)
11559           {
11560             if (initialized)
11561               {
11562                 if (!staticp)
11563                   {
11564                     /* An attempt is being made to initialize a non-static
11565                        member.  But, from [class.mem]:
11566
11567                        4 A member-declarator can contain a
11568                        constant-initializer only if it declares a static
11569                        member (_class.static_) of integral or enumeration
11570                        type, see _class.static.data_.
11571
11572                        This used to be relatively common practice, but
11573                        the rest of the compiler does not correctly
11574                        handle the initialization unless the member is
11575                        static so we make it static below.  */
11576                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11577                                 declarator);
11578                     cp_pedwarn ("making `%D' static", declarator);
11579                     staticp = 1;
11580                   }
11581
11582                 if (uses_template_parms (type))
11583                   /* We'll check at instantiation time.  */
11584                   ;
11585                 else if (check_static_variable_definition (declarator,
11586                                                            type))
11587                   /* If we just return the declaration, crashes
11588                      will sometimes occur.  We therefore return
11589                      void_type_node, as if this was a friend
11590                      declaration, to cause callers to completely
11591                      ignore this declaration.  */
11592                   return void_type_node;
11593               }
11594
11595             /* 9.2p13 [class.mem] */
11596             if (declarator == constructor_name (current_class_type)
11597                 /* The standard does not allow non-static data members
11598                    here either, but we agreed at the 10/99 meeting
11599                    to change that in TC 1 so that they are allowed in
11600                    classes with no user-defined constructors.  */
11601                 && staticp)
11602               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11603                           declarator);
11604
11605             if (staticp)
11606               {
11607                 /* C++ allows static class members.  All other work
11608                    for this is done by grokfield.  */
11609                 decl = build_lang_decl (VAR_DECL, declarator, type);
11610                 TREE_STATIC (decl) = 1;
11611                 /* In class context, 'static' means public access.  */
11612                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11613               }
11614             else
11615               {
11616                 decl = build_decl (FIELD_DECL, declarator, type);
11617                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11618                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11619                   {
11620                     DECL_MUTABLE_P (decl) = 1;
11621                     RIDBIT_RESET (RID_MUTABLE, specbits);
11622                   }
11623               }
11624
11625             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11626                             inlinep, friendp, raises != NULL_TREE);
11627           }
11628       }
11629     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11630       {
11631         tree original_name;
11632         int publicp = 0;
11633
11634         if (! declarator)
11635           return NULL_TREE;
11636
11637         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11638           original_name = dname;
11639         else
11640           original_name = declarator;
11641
11642         if (RIDBIT_SETP (RID_AUTO, specbits))
11643           error ("storage class `auto' invalid for function `%s'", name);
11644         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11645           error ("storage class `register' invalid for function `%s'", name);
11646
11647         /* Function declaration not at top level.
11648            Storage classes other than `extern' are not allowed
11649            and `extern' makes no difference.  */
11650         if (! toplevel_bindings_p ()
11651             && (RIDBIT_SETP (RID_STATIC, specbits)
11652                 || RIDBIT_SETP (RID_INLINE, specbits))
11653             && pedantic)
11654           {
11655             if (RIDBIT_SETP (RID_STATIC, specbits))
11656               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11657             else
11658               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11659           }
11660
11661         if (ctype == NULL_TREE)
11662           {
11663             if (virtualp)
11664               {
11665                 error ("virtual non-class function `%s'", name);
11666                 virtualp = 0;
11667               }
11668           }
11669         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11670           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11671                                           TYPE_ARG_TYPES (type));
11672
11673         /* Record presence of `static'.  */
11674         publicp = (ctype != NULL_TREE
11675                    || RIDBIT_SETP (RID_EXTERN, specbits)
11676                    || !RIDBIT_SETP (RID_STATIC, specbits));
11677
11678         decl = grokfndecl (ctype, type, original_name, declarator,
11679                            virtualp, flags, quals, raises,
11680                            1, friendp,
11681                            publicp, inlinep, funcdef_flag,
11682                            template_count, in_namespace);
11683         if (decl == NULL_TREE)
11684           return NULL_TREE;
11685
11686         if (staticp == 1)
11687           {
11688             int illegal_static = 0;
11689
11690             /* Don't allow a static member function in a class, and forbid
11691                declaring main to be static.  */
11692             if (TREE_CODE (type) == METHOD_TYPE)
11693               {
11694                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11695                 illegal_static = 1;
11696               }
11697             else if (current_function_decl)
11698               {
11699                 /* FIXME need arm citation */
11700                 error ("cannot declare static function inside another function");
11701                 illegal_static = 1;
11702               }
11703
11704             if (illegal_static)
11705               {
11706                 staticp = 0;
11707                 RIDBIT_RESET (RID_STATIC, specbits);
11708               }
11709           }
11710       }
11711     else
11712       {
11713         /* It's a variable.  */
11714
11715         /* An uninitialized decl with `extern' is a reference.  */
11716         decl = grokvardecl (type, declarator, &specbits,
11717                             initialized,
11718                             (type_quals & TYPE_QUAL_CONST) != 0,
11719                             in_namespace);
11720         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11721                         inlinep, friendp, raises != NULL_TREE);
11722
11723         if (ctype)
11724           {
11725             DECL_CONTEXT (decl) = ctype;
11726             if (staticp == 1)
11727               {
11728                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11729                 staticp = 0;
11730                 RIDBIT_RESET (RID_STATIC, specbits);
11731               }
11732             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11733               {
11734                 cp_error ("static member `%D' declared `register'", decl);
11735                 RIDBIT_RESET (RID_REGISTER, specbits);
11736               }
11737             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11738               {
11739                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11740                             decl);
11741                 RIDBIT_RESET (RID_EXTERN, specbits);
11742               }
11743           }
11744       }
11745
11746     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11747
11748     /* Record `register' declaration for warnings on &
11749        and in case doing stupid register allocation.  */
11750
11751     if (RIDBIT_SETP (RID_REGISTER, specbits))
11752       DECL_REGISTER (decl) = 1;
11753
11754     if (RIDBIT_SETP (RID_EXTERN, specbits))
11755       DECL_THIS_EXTERN (decl) = 1;
11756
11757     if (RIDBIT_SETP (RID_STATIC, specbits))
11758       DECL_THIS_STATIC (decl) = 1;
11759
11760     /* Record constancy and volatility.  There's no need to do this
11761        when processing a template; we'll do this for the instantiated
11762        declaration based on the type of DECL.  */
11763     if (!processing_template_decl)
11764       c_apply_type_quals_to_decl (type_quals, decl);
11765
11766     return decl;
11767   }
11768 }
11769 \f
11770 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11771    An empty exprlist is a parmlist.  An exprlist which
11772    contains only identifiers at the global level
11773    is a parmlist.  Otherwise, it is an exprlist.  */
11774
11775 int
11776 parmlist_is_exprlist (exprs)
11777      tree exprs;
11778 {
11779   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11780     return 0;
11781
11782   if (toplevel_bindings_p ())
11783     {
11784       /* At the global level, if these are all identifiers,
11785          then it is a parmlist.  */
11786       while (exprs)
11787         {
11788           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11789             return 1;
11790           exprs = TREE_CHAIN (exprs);
11791         }
11792       return 0;
11793     }
11794   return 1;
11795 }
11796
11797 /* Subroutine of start_function.  Ensure that each of the parameter
11798    types (as listed in PARMS) is complete, as is required for a
11799    function definition.  */
11800
11801 static void
11802 require_complete_types_for_parms (parms)
11803      tree parms;
11804 {
11805   for (; parms; parms = TREE_CHAIN (parms))
11806     {
11807       tree type = TREE_TYPE (parms);
11808
11809       /* Try to complete the TYPE.  */
11810       type = complete_type (type);
11811
11812       if (type == error_mark_node)
11813         continue;
11814
11815       if (!COMPLETE_TYPE_P (type))
11816         {
11817           if (DECL_NAME (parms))
11818             error ("parameter `%s' has incomplete type",
11819                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11820           else
11821             error ("parameter has incomplete type");
11822           TREE_TYPE (parms) = error_mark_node;
11823         }
11824       else
11825         layout_decl (parms, 0);
11826     }
11827 }
11828
11829 /* Returns non-zero if T is a local variable.  */
11830
11831 int
11832 local_variable_p (t)
11833      tree t;
11834 {
11835   if ((TREE_CODE (t) == VAR_DECL
11836        /* A VAR_DECL with a context that is a _TYPE is a static data
11837           member.  */
11838        && !TYPE_P (CP_DECL_CONTEXT (t))
11839        /* Any other non-local variable must be at namespace scope.  */
11840        && !DECL_NAMESPACE_SCOPE_P (t))
11841       || (TREE_CODE (t) == PARM_DECL))
11842     return 1;
11843
11844   return 0;
11845 }
11846
11847 /* Returns non-zero if T is an automatic local variable or a label.
11848    (These are the declarations that need to be remapped when the code
11849    containing them is duplicated.)  */
11850
11851 int
11852 nonstatic_local_decl_p (t)
11853      tree t;
11854 {
11855   return ((local_variable_p (t) && !TREE_STATIC (t))
11856           || TREE_CODE (t) == LABEL_DECL
11857           || TREE_CODE (t) == RESULT_DECL);
11858 }
11859
11860 /* Like local_variable_p, but suitable for use as a tree-walking
11861    function.  */
11862
11863 static tree
11864 local_variable_p_walkfn (tp, walk_subtrees, data)
11865      tree *tp;
11866      int *walk_subtrees ATTRIBUTE_UNUSED;
11867      void *data ATTRIBUTE_UNUSED;
11868 {
11869   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11870           ? *tp : NULL_TREE);
11871 }
11872
11873 /* Check that ARG, which is a default-argument expression for a
11874    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11875    something goes wrong.  DECL may also be a _TYPE node, rather than a
11876    DECL, if there is no DECL available.  */
11877
11878 tree
11879 check_default_argument (decl, arg)
11880      tree decl;
11881      tree arg;
11882 {
11883   tree var;
11884   tree decl_type;
11885
11886   if (TREE_CODE (arg) == DEFAULT_ARG)
11887     /* We get a DEFAULT_ARG when looking at an in-class declaration
11888        with a default argument.  Ignore the argument for now; we'll
11889        deal with it after the class is complete.  */
11890     return arg;
11891
11892   if (processing_template_decl || uses_template_parms (arg))
11893     /* We don't do anything checking until instantiation-time.  Note
11894        that there may be uninstantiated arguments even for an
11895        instantiated function, since default arguments are not
11896        instantiated until they are needed.  */
11897     return arg;
11898
11899   if (TYPE_P (decl))
11900     {
11901       decl_type = decl;
11902       decl = NULL_TREE;
11903     }
11904   else
11905     decl_type = TREE_TYPE (decl);
11906
11907   if (arg == error_mark_node
11908       || decl == error_mark_node
11909       || TREE_TYPE (arg) == error_mark_node
11910       || decl_type == error_mark_node)
11911     /* Something already went wrong.  There's no need to check
11912        further.  */
11913     return error_mark_node;
11914
11915   /* [dcl.fct.default]
11916
11917      A default argument expression is implicitly converted to the
11918      parameter type.  */
11919   if (!TREE_TYPE (arg)
11920       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11921     {
11922       if (decl)
11923         cp_error ("default argument for `%#D' has type `%T'",
11924                   decl, TREE_TYPE (arg));
11925       else
11926         cp_error ("default argument for parameter of type `%T' has type `%T'",
11927                   decl_type, TREE_TYPE (arg));
11928
11929       return error_mark_node;
11930     }
11931
11932   /* [dcl.fct.default]
11933
11934      Local variables shall not be used in default argument
11935      expressions.
11936
11937      The keyword `this' shall not be used in a default argument of a
11938      member function.  */
11939   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11940   if (var)
11941     {
11942       cp_error ("default argument `%E' uses local variable `%D'",
11943                 arg, var);
11944       return error_mark_node;
11945     }
11946
11947   /* All is well.  */
11948   return arg;
11949 }
11950
11951 /* Decode the list of parameter types for a function type.
11952    Given the list of things declared inside the parens,
11953    return a list of types.
11954
11955    The list we receive can have three kinds of elements:
11956    an IDENTIFIER_NODE for names given without types,
11957    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11958    or void_type_node, to mark the end of an argument list
11959    when additional arguments are not permitted (... was not used).
11960
11961    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11962    a mere declaration.  A nonempty identifier-list gets an error message
11963    when FUNCDEF_FLAG is zero.
11964    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11965    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11966
11967    If all elements of the input list contain types,
11968    we return a list of the types.
11969    If all elements contain no type (except perhaps a void_type_node
11970    at the end), we return a null list.
11971    If some have types and some do not, it is an error, and we
11972    return a null list.
11973
11974    Also set last_function_parms to either
11975    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11976    A list of names is converted to a chain of PARM_DECLs
11977    by store_parm_decls so that ultimately it is always a chain of decls.
11978
11979    Note that in C++, parameters can take default values.  These default
11980    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11981    an error to specify default values which are followed by parameters
11982    that have no default values, or an ELLIPSES.  For simplicities sake,
11983    only parameters which are specified with their types can take on
11984    default values.  */
11985
11986 static tree
11987 grokparms (first_parm, funcdef_flag)
11988      tree first_parm;
11989      int funcdef_flag;
11990 {
11991   tree result = NULL_TREE;
11992   tree decls = NULL_TREE;
11993
11994   if (first_parm != NULL_TREE
11995       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11996     {
11997       if (! funcdef_flag)
11998         pedwarn ("parameter names (without types) in function declaration");
11999       last_function_parms = first_parm;
12000       return NULL_TREE;
12001     }
12002   else if (first_parm != NULL_TREE
12003            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
12004            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
12005     my_friendly_abort (145);
12006   else
12007     {
12008       /* Types were specified.  This is a list of declarators
12009          each represented as a TREE_LIST node.  */
12010       register tree parm, chain;
12011       int any_init = 0, any_error = 0;
12012
12013       if (first_parm != NULL_TREE)
12014         {
12015           tree last_result = NULL_TREE;
12016           tree last_decl = NULL_TREE;
12017
12018           for (parm = first_parm; parm != NULL_TREE; parm = chain)
12019             {
12020               tree type = NULL_TREE, list_node = parm;
12021               register tree decl = TREE_VALUE (parm);
12022               tree init = TREE_PURPOSE (parm);
12023
12024               chain = TREE_CHAIN (parm);
12025               /* @@ weak defense against parse errors.  */
12026               if (TREE_CODE (decl) != VOID_TYPE
12027                   && TREE_CODE (decl) != TREE_LIST)
12028                 {
12029                   /* Give various messages as the need arises.  */
12030                   if (TREE_CODE (decl) == STRING_CST)
12031                     cp_error ("invalid string constant `%E'", decl);
12032                   else if (TREE_CODE (decl) == INTEGER_CST)
12033                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12034                   continue;
12035                 }
12036
12037               if (TREE_CODE (decl) != VOID_TYPE)
12038                 {
12039                   decl = grokdeclarator (TREE_VALUE (decl),
12040                                          TREE_PURPOSE (decl),
12041                                          PARM, init != NULL_TREE,
12042                                          NULL_TREE);
12043                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12044                     continue;
12045
12046                   /* Top-level qualifiers on the parameters are
12047                      ignored for function types.  */
12048                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12049
12050                   if (TREE_CODE (type) == VOID_TYPE)
12051                     decl = void_type_node;
12052                   else if (TREE_CODE (type) == METHOD_TYPE)
12053                     {
12054                       if (DECL_NAME (decl))
12055                         /* Cannot use the decl here because
12056                            we don't have DECL_CONTEXT set up yet.  */
12057                         cp_error ("parameter `%D' invalidly declared method type",
12058                                   DECL_NAME (decl));
12059                       else
12060                         error ("parameter invalidly declared method type");
12061                       type = build_pointer_type (type);
12062                       TREE_TYPE (decl) = type;
12063                     }
12064                   else if (TREE_CODE (type) == OFFSET_TYPE)
12065                     {
12066                       if (DECL_NAME (decl))
12067                         cp_error ("parameter `%D' invalidly declared offset type",
12068                                   DECL_NAME (decl));
12069                       else
12070                         error ("parameter invalidly declared offset type");
12071                       type = build_pointer_type (type);
12072                       TREE_TYPE (decl) = type;
12073                     }
12074                   else if (abstract_virtuals_error (decl, type))
12075                     any_error = 1;  /* Seems like a good idea. */
12076                   else if (POINTER_TYPE_P (type))
12077                     {
12078                       tree t = type;
12079                       while (POINTER_TYPE_P (t)
12080                              || (TREE_CODE (t) == ARRAY_TYPE
12081                                  && TYPE_DOMAIN (t) != NULL_TREE))
12082                         t = TREE_TYPE (t);
12083                       if (TREE_CODE (t) == ARRAY_TYPE)
12084                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12085                                   type,
12086                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12087                     }
12088                 }
12089
12090               if (TREE_CODE (decl) == VOID_TYPE)
12091                 {
12092                   if (result == NULL_TREE)
12093                     {
12094                       result = void_list_node;
12095                       last_result = result;
12096                     }
12097                   else
12098                     {
12099                       TREE_CHAIN (last_result) = void_list_node;
12100                       last_result = void_list_node;
12101                     }
12102                   if (chain
12103                       && (chain != void_list_node || TREE_CHAIN (chain)))
12104                     error ("`void' in parameter list must be entire list");
12105                   break;
12106                 }
12107
12108               /* Since there is a prototype, args are passed in their own types.  */
12109               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12110               if (PROMOTE_PROTOTYPES
12111                   && (TREE_CODE (type) == INTEGER_TYPE
12112                       || TREE_CODE (type) == ENUMERAL_TYPE)
12113                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12114                 DECL_ARG_TYPE (decl) = integer_type_node;
12115               if (!any_error && init)
12116                 {
12117                   any_init++;
12118                   init = check_default_argument (decl, init);
12119                 }
12120               else
12121                 init = NULL_TREE;
12122
12123               if (decls == NULL_TREE)
12124                 {
12125                   decls = decl;
12126                   last_decl = decls;
12127                 }
12128               else
12129                 {
12130                   TREE_CHAIN (last_decl) = decl;
12131                   last_decl = decl;
12132                 }
12133               list_node = tree_cons (init, type, NULL_TREE);
12134               if (result == NULL_TREE)
12135                 {
12136                   result = list_node;
12137                   last_result = result;
12138                 }
12139               else
12140                 {
12141                   TREE_CHAIN (last_result) = list_node;
12142                   last_result = list_node;
12143                 }
12144             }
12145           if (last_result)
12146             TREE_CHAIN (last_result) = NULL_TREE;
12147           /* If there are no parameters, and the function does not end
12148              with `...', then last_decl will be NULL_TREE.  */
12149           if (last_decl != NULL_TREE)
12150             TREE_CHAIN (last_decl) = NULL_TREE;
12151         }
12152     }
12153
12154   last_function_parms = decls;
12155
12156   return result;
12157 }
12158
12159 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12160    FUNCTION_TYPE with the newly parsed version of its default argument, which
12161    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12162
12163 void
12164 replace_defarg (arg, init)
12165      tree arg, init;
12166 {
12167   if (! processing_template_decl
12168       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12169     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12170                 TREE_TYPE (init), TREE_VALUE (arg));
12171   TREE_PURPOSE (arg) = init;
12172 }
12173 \f
12174 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12175    D's arguments allow it to be a copy constructor, or copy assignment
12176    operator.  */
12177
12178 int
12179 copy_args_p (d)
12180      tree d;
12181 {
12182   tree t;
12183
12184   if (!DECL_FUNCTION_MEMBER_P (d))
12185     return 0;
12186
12187   t = FUNCTION_ARG_CHAIN (d);
12188   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12189     t = TREE_CHAIN (t);
12190   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12191       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12192           == DECL_CONTEXT (d))
12193       && (TREE_CHAIN (t) == NULL_TREE
12194           || TREE_CHAIN (t) == void_list_node
12195           || TREE_PURPOSE (TREE_CHAIN (t))))
12196     return 1;
12197   return 0;
12198 }
12199
12200 /* These memoizing functions keep track of special properties which
12201    a class may have.  `grok_ctor_properties' notices whether a class
12202    has a constructor of the form X(X&), and also complains
12203    if the class has a constructor of the form X(X).
12204    `grok_op_properties' takes notice of the various forms of
12205    operator= which are defined, as well as what sorts of type conversion
12206    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12207
12208 int
12209 grok_ctor_properties (ctype, decl)
12210      tree ctype, decl;
12211 {
12212   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12213   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12214
12215   /* When a type has virtual baseclasses, a magical first int argument is
12216      added to any ctor so we can tell if the class has been initialized
12217      yet.  This could screw things up in this function, so we deliberately
12218      ignore the leading int if we're in that situation.  */
12219   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12220     {
12221       my_friendly_assert (parmtypes
12222                           && TREE_VALUE (parmtypes) == integer_type_node,
12223                           980529);
12224       parmtypes = TREE_CHAIN (parmtypes);
12225       parmtype = TREE_VALUE (parmtypes);
12226     }
12227
12228   /* [class.copy]
12229
12230      A non-template constructor for class X is a copy constructor if
12231      its first parameter is of type X&, const X&, volatile X& or const
12232      volatile X&, and either there are no other parameters or else all
12233      other parameters have default arguments.  */
12234   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12235       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12236       && (TREE_CHAIN (parmtypes) == NULL_TREE
12237           || TREE_CHAIN (parmtypes) == void_list_node
12238           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12239       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12240            && is_member_template (DECL_TI_TEMPLATE (decl))))
12241     {
12242       TYPE_HAS_INIT_REF (ctype) = 1;
12243       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12244         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12245     }
12246   /* [class.copy]
12247
12248      A declaration of a constructor for a class X is ill-formed if its
12249      first parameter is of type (optionally cv-qualified) X and either
12250      there are no other parameters or else all other parameters have
12251      default arguments.
12252
12253      We *don't* complain about member template instantiations that
12254      have this form, though; they can occur as we try to decide what
12255      constructor to use during overload resolution.  Since overload
12256      resolution will never prefer such a constructor to the
12257      non-template copy constructor (which is either explicitly or
12258      implicitly defined), there's no need to worry about their
12259      existence.  Theoretically, they should never even be
12260      instantiated, but that's hard to forestall.  */
12261   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12262            && (TREE_CHAIN (parmtypes) == NULL_TREE
12263                || TREE_CHAIN (parmtypes) == void_list_node
12264                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12265            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12266                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12267     {
12268       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12269                 ctype, ctype);
12270       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12271       return 0;
12272     }
12273   else if (TREE_CODE (parmtype) == VOID_TYPE
12274            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12275     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12276
12277   return 1;
12278 }
12279
12280 /* An operator with this code is unary, but can also be binary.  */
12281
12282 static int
12283 ambi_op_p (code)
12284      enum tree_code code;
12285 {
12286   return (code == INDIRECT_REF
12287           || code == ADDR_EXPR
12288           || code == CONVERT_EXPR
12289           || code == NEGATE_EXPR
12290           || code == PREINCREMENT_EXPR
12291           || code == PREDECREMENT_EXPR);
12292 }
12293
12294 /* An operator with this name can only be unary.  */
12295
12296 static int
12297 unary_op_p (code)
12298      enum tree_code code;
12299 {
12300   return (code == TRUTH_NOT_EXPR
12301           || code == BIT_NOT_EXPR
12302           || code == COMPONENT_REF
12303           || code == TYPE_EXPR);
12304 }
12305
12306 /* Do a little sanity-checking on how they declared their operator.  */
12307
12308 void
12309 grok_op_properties (decl, virtualp, friendp)
12310      tree decl;
12311      int virtualp, friendp;
12312 {
12313   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12314   tree argtype;
12315   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12316   tree name = DECL_NAME (decl);
12317   enum tree_code operator_code;
12318   int arity;
12319
12320   /* Count the number of arguments.  */
12321   for (argtype = argtypes, arity = 0;
12322        argtype && argtype != void_list_node;
12323        argtype = TREE_CHAIN (argtype))
12324     ++arity;
12325
12326   if (current_class_type == NULL_TREE)
12327     friendp = 1;
12328
12329   if (DECL_CONV_FN_P (decl))
12330     operator_code = TYPE_EXPR;
12331   else
12332     do
12333       {
12334 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12335         if (ansi_opname (CODE) == name)                                     \
12336           {                                                                 \
12337             operator_code = CODE;                                           \
12338             break;                                                          \
12339           }                                                                 \
12340         else if (ansi_assopname (CODE) == name)                             \
12341           {                                                                 \
12342             operator_code = CODE;                                           \
12343             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12344             break;                                                          \
12345           }
12346
12347 #include "operators.def"
12348 #undef DEF_OPERATOR
12349
12350         my_friendly_abort (20000527);
12351       }
12352     while (0);
12353   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12354   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12355
12356   if (! friendp)
12357     {
12358       switch (operator_code)
12359         {
12360         case CALL_EXPR:
12361           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12362           break;
12363
12364         case ARRAY_REF:
12365           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12366           break;
12367
12368         case COMPONENT_REF:
12369         case MEMBER_REF:
12370           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12371           break;
12372
12373         case NEW_EXPR:
12374           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12375           break;
12376
12377         case DELETE_EXPR:
12378           TYPE_GETS_DELETE (current_class_type) |= 1;
12379           break;
12380
12381         case VEC_NEW_EXPR:
12382           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12383           break;
12384
12385         case VEC_DELETE_EXPR:
12386           TYPE_GETS_DELETE (current_class_type) |= 2;
12387           break;
12388
12389         default:
12390           break;
12391         }
12392     }
12393
12394   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12395     {
12396       /* When the compiler encounters the definition of A::operator new, it
12397          doesn't look at the class declaration to find out if it's static.  */
12398       if (methodp)
12399         revert_static_member_fn (decl);
12400
12401       /* Take care of function decl if we had syntax errors.  */
12402       if (argtypes == NULL_TREE)
12403         TREE_TYPE (decl)
12404           = build_function_type (ptr_type_node,
12405                                  hash_tree_chain (integer_type_node,
12406                                                   void_list_node));
12407       else
12408         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12409     }
12410   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12411     {
12412       if (methodp)
12413         revert_static_member_fn (decl);
12414
12415       if (argtypes == NULL_TREE)
12416         TREE_TYPE (decl)
12417           = build_function_type (void_type_node,
12418                                  hash_tree_chain (ptr_type_node,
12419                                                   void_list_node));
12420       else
12421         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12422     }
12423   else
12424     {
12425       /* An operator function must either be a non-static member function
12426          or have at least one parameter of a class, a reference to a class,
12427          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12428       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12429         {
12430           if (operator_code == TYPE_EXPR
12431               || operator_code == CALL_EXPR
12432               || operator_code == COMPONENT_REF
12433               || operator_code == ARRAY_REF
12434               || operator_code == NOP_EXPR)
12435             cp_error ("`%D' must be a nonstatic member function", decl);
12436           else
12437             {
12438               tree p = argtypes;
12439
12440               if (DECL_STATIC_FUNCTION_P (decl))
12441                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12442
12443               if (p)
12444                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12445                   {
12446                     tree arg = TREE_VALUE (p);
12447                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12448                       arg = TREE_TYPE (arg);
12449
12450                     /* This lets bad template code slip through.  */
12451                     if (IS_AGGR_TYPE (arg)
12452                         || TREE_CODE (arg) == ENUMERAL_TYPE
12453                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12454                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12455                       goto foundaggr;
12456                   }
12457               cp_error
12458                 ("`%D' must have an argument of class or enumerated type",
12459                  decl);
12460             foundaggr:
12461               ;
12462             }
12463         }
12464
12465       if (operator_code == CALL_EXPR)
12466         return;                 /* No restrictions on args. */
12467
12468       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12469         {
12470           tree t = TREE_TYPE (name);
12471           if (! friendp)
12472             {
12473               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12474               const char *what = 0;
12475
12476               if (ref)
12477                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12478
12479               if (TREE_CODE (t) == VOID_TYPE)
12480                 what = "void";
12481               else if (t == current_class_type)
12482                 what = "the same type";
12483               /* Don't force t to be complete here.  */
12484               else if (IS_AGGR_TYPE (t)
12485                        && COMPLETE_TYPE_P (t)
12486                        && DERIVED_FROM_P (t, current_class_type))
12487                 what = "a base class";
12488
12489               if (what)
12490                 warning ("conversion to %s%s will never use a type conversion operator",
12491                          ref ? "a reference to " : "", what);
12492             }
12493         }
12494
12495       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12496           && operator_code == NOP_EXPR)
12497         {
12498           tree parmtype;
12499
12500           if (arity != 2 && methodp)
12501             {
12502               cp_error ("`%D' must take exactly one argument", decl);
12503               return;
12504             }
12505           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12506
12507           /* [class.copy]
12508
12509              A user-declared copy assignment operator X::operator= is
12510              a non-static non-template member function of class X with
12511              exactly one parameter of type X, X&, const X&, volatile
12512              X& or const volatile X&.  */
12513           if (copy_assignment_arg_p (parmtype, virtualp)
12514               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12515                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12516               && ! friendp)
12517             {
12518               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12519               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12520                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12521                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12522             }
12523         }
12524       else if (operator_code == COND_EXPR)
12525         {
12526           /* 13.4.0.3 */
12527           cp_error ("ISO C++ prohibits overloading operator ?:");
12528         }
12529       else if (ambi_op_p (operator_code))
12530         {
12531           if (arity == 1)
12532             /* We pick the one-argument operator codes by default, so
12533                we don't have to change anything.  */
12534             ;
12535           else if (arity == 2)
12536             {
12537               /* If we thought this was a unary operator, we now know
12538                  it to be a binary operator.  */
12539               switch (operator_code)
12540                 {
12541                 case INDIRECT_REF:
12542                   operator_code = MULT_EXPR;
12543                   break;
12544
12545                 case ADDR_EXPR:
12546                   operator_code = BIT_AND_EXPR;
12547                   break;
12548
12549                 case CONVERT_EXPR:
12550                   operator_code = PLUS_EXPR;
12551                   break;
12552
12553                 case NEGATE_EXPR:
12554                   operator_code = MINUS_EXPR;
12555                   break;
12556
12557                 case PREINCREMENT_EXPR:
12558                   operator_code = POSTINCREMENT_EXPR;
12559                   break;
12560
12561                 case PREDECREMENT_EXPR:
12562                   operator_code = POSTDECREMENT_EXPR;
12563                   break;
12564
12565                 default:
12566                   my_friendly_abort (20000527);
12567                 }
12568
12569               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12570
12571               if ((operator_code == POSTINCREMENT_EXPR
12572                    || operator_code == POSTDECREMENT_EXPR)
12573                   && ! processing_template_decl
12574                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12575                 {
12576                   if (methodp)
12577                     cp_error ("postfix `%D' must take `int' as its argument",
12578                               decl);
12579                   else
12580                     cp_error
12581                       ("postfix `%D' must take `int' as its second argument",
12582                        decl);
12583                 }
12584             }
12585           else
12586             {
12587               if (methodp)
12588                 cp_error ("`%D' must take either zero or one argument", decl);
12589               else
12590                 cp_error ("`%D' must take either one or two arguments", decl);
12591             }
12592
12593           /* More Effective C++ rule 6.  */
12594           if (warn_ecpp
12595               && (operator_code == POSTINCREMENT_EXPR
12596                   || operator_code == POSTDECREMENT_EXPR
12597                   || operator_code == PREINCREMENT_EXPR
12598                   || operator_code == PREDECREMENT_EXPR))
12599             {
12600               tree arg = TREE_VALUE (argtypes);
12601               tree ret = TREE_TYPE (TREE_TYPE (decl));
12602               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12603                 arg = TREE_TYPE (arg);
12604               arg = TYPE_MAIN_VARIANT (arg);
12605               if (operator_code == PREINCREMENT_EXPR
12606                   || operator_code == PREDECREMENT_EXPR)
12607                 {
12608                   if (TREE_CODE (ret) != REFERENCE_TYPE
12609                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12610                                        arg))
12611                     cp_warning ("prefix `%D' should return `%T'", decl,
12612                                 build_reference_type (arg));
12613                 }
12614               else
12615                 {
12616                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12617                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12618                 }
12619             }
12620         }
12621       else if (unary_op_p (operator_code))
12622         {
12623           if (arity != 1)
12624             {
12625               if (methodp)
12626                 cp_error ("`%D' must take `void'", decl);
12627               else
12628                 cp_error ("`%D' must take exactly one argument", decl);
12629             }
12630         }
12631       else /* if (binary_op_p (operator_code)) */
12632         {
12633           if (arity != 2)
12634             {
12635               if (methodp)
12636                 cp_error ("`%D' must take exactly one argument", decl);
12637               else
12638                 cp_error ("`%D' must take exactly two arguments", decl);
12639             }
12640
12641           /* More Effective C++ rule 7.  */
12642           if (warn_ecpp
12643               && (operator_code == TRUTH_ANDIF_EXPR
12644                   || operator_code == TRUTH_ORIF_EXPR
12645                   || operator_code == COMPOUND_EXPR))
12646             cp_warning ("user-defined `%D' always evaluates both arguments",
12647                         decl);
12648         }
12649
12650       /* Effective C++ rule 23.  */
12651       if (warn_ecpp
12652           && arity == 2
12653           && (operator_code == PLUS_EXPR
12654               || operator_code == MINUS_EXPR
12655               || operator_code == TRUNC_DIV_EXPR
12656               || operator_code == MULT_EXPR)
12657           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12658         cp_warning ("`%D' should return by value", decl);
12659
12660       /* 13.4.0.8 */
12661       for (; argtypes && argtypes != void_list_node;
12662           argtypes = TREE_CHAIN (argtypes))
12663         if (TREE_PURPOSE (argtypes))
12664           {
12665             TREE_PURPOSE (argtypes) = NULL_TREE;
12666             if (operator_code == POSTINCREMENT_EXPR
12667                 || operator_code == POSTDECREMENT_EXPR)
12668               {
12669                 if (pedantic)
12670                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12671               }
12672             else
12673               cp_error ("`%D' cannot have default arguments", decl);
12674           }
12675
12676     }
12677 }
12678 \f
12679 static const char *
12680 tag_name (code)
12681      enum tag_types code;
12682 {
12683   switch (code)
12684     {
12685     case record_type:
12686       return "struct";
12687     case class_type:
12688       return "class";
12689     case union_type:
12690       return "union ";
12691     case enum_type:
12692       return "enum";
12693     default:
12694       my_friendly_abort (981122);
12695     }
12696 }
12697
12698 /* Get the struct, enum or union (CODE says which) with tag NAME.
12699    Define the tag as a forward-reference if it is not defined.
12700
12701    C++: If a class derivation is given, process it here, and report
12702    an error if multiple derivation declarations are not identical.
12703
12704    If this is a definition, come in through xref_tag and only look in
12705    the current frame for the name (since C++ allows new names in any
12706    scope.)  */
12707
12708 tree
12709 xref_tag (code_type_node, name, globalize)
12710      tree code_type_node;
12711      tree name;
12712      int globalize;
12713 {
12714   enum tag_types tag_code;
12715   enum tree_code code;
12716   register tree ref, t;
12717   struct binding_level *b = current_binding_level;
12718   int got_type = 0;
12719   tree attributes = NULL_TREE;
12720   tree context = NULL_TREE;
12721
12722   /* If we are called from the parser, code_type_node will sometimes be a
12723      TREE_LIST.  This indicates that the user wrote
12724      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12725      use them later.  */
12726   if (TREE_CODE (code_type_node) == TREE_LIST)
12727     {
12728       attributes = TREE_PURPOSE (code_type_node);
12729       code_type_node = TREE_VALUE (code_type_node);
12730     }
12731
12732   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12733   switch (tag_code)
12734     {
12735     case record_type:
12736     case class_type:
12737       code = RECORD_TYPE;
12738       break;
12739     case union_type:
12740       code = UNION_TYPE;
12741       break;
12742     case enum_type:
12743       code = ENUMERAL_TYPE;
12744       break;
12745     default:
12746       my_friendly_abort (18);
12747     }
12748
12749   /* If a cross reference is requested, look up the type
12750      already defined for this tag and return it.  */
12751   if (TYPE_P (name))
12752     {
12753       t = name;
12754       name = TYPE_IDENTIFIER (t);
12755       got_type = 1;
12756     }
12757   else
12758     t = IDENTIFIER_TYPE_VALUE (name);
12759
12760   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12761       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12762     t = NULL_TREE;
12763
12764   if (! globalize)
12765     {
12766       /* If we know we are defining this tag, only look it up in
12767          this scope and don't try to find it as a type.  */
12768       ref = lookup_tag (code, name, b, 1);
12769     }
12770   else
12771     {
12772       if (t)
12773         {
12774           /* [dcl.type.elab] If the identifier resolves to a
12775              typedef-name or a template type-parameter, the
12776              elaborated-type-specifier is ill-formed.  */
12777           if (t != TYPE_MAIN_VARIANT (t)
12778               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12779             cp_pedwarn ("using typedef-name `%D' after `%s'",
12780                         TYPE_NAME (t), tag_name (tag_code));
12781           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12782             cp_error ("using template type parameter `%T' after `%s'",
12783                       t, tag_name (tag_code));
12784
12785           ref = t;
12786         }
12787       else
12788         ref = lookup_tag (code, name, b, 0);
12789
12790       if (! ref)
12791         {
12792           /* Try finding it as a type declaration.  If that wins,
12793              use it.  */
12794           ref = lookup_name (name, 1);
12795
12796           if (ref != NULL_TREE
12797               && processing_template_decl
12798               && DECL_CLASS_TEMPLATE_P (ref)
12799               && template_class_depth (current_class_type) == 0)
12800             /* Since GLOBALIZE is true, we're declaring a global
12801                template, so we want this type.  */
12802             ref = DECL_TEMPLATE_RESULT (ref);
12803
12804           if (ref && TREE_CODE (ref) == TYPE_DECL
12805               && TREE_CODE (TREE_TYPE (ref)) == code)
12806             ref = TREE_TYPE (ref);
12807           else
12808             ref = NULL_TREE;
12809         }
12810
12811       if (ref && current_class_type
12812           && template_class_depth (current_class_type)
12813           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12814         {
12815           /* Since GLOBALIZE is non-zero, we are not looking at a
12816              definition of this tag.  Since, in addition, we are currently
12817              processing a (member) template declaration of a template
12818              class, we must be very careful; consider:
12819
12820                template <class X>
12821                struct S1
12822
12823                template <class U>
12824                struct S2
12825                { template <class V>
12826                friend struct S1; };
12827
12828              Here, the S2::S1 declaration should not be confused with the
12829              outer declaration.  In particular, the inner version should
12830              have a template parameter of level 2, not level 1.  This
12831              would be particularly important if the member declaration
12832              were instead:
12833
12834                template <class V = U> friend struct S1;
12835
12836              say, when we should tsubst into `U' when instantiating
12837              S2.  On the other hand, when presented with:
12838
12839                  template <class T>
12840                  struct S1 {
12841                    template <class U>
12842                    struct S2 {};
12843                    template <class U>
12844                    friend struct S2;
12845                  };
12846
12847               we must find the inner binding eventually.  We
12848               accomplish this by making sure that the new type we
12849               create to represent this declaration has the right
12850               TYPE_CONTEXT.  */
12851           context = TYPE_CONTEXT (ref);
12852           ref = NULL_TREE;
12853         }
12854     }
12855
12856   if (! ref)
12857     {
12858       /* If no such tag is yet defined, create a forward-reference node
12859          and record it as the "definition".
12860          When a real declaration of this type is found,
12861          the forward-reference will be altered into a real type.  */
12862       if (code == ENUMERAL_TYPE)
12863         {
12864           cp_error ("use of enum `%#D' without previous declaration", name);
12865
12866           ref = make_node (ENUMERAL_TYPE);
12867
12868           /* Give the type a default layout like unsigned int
12869              to avoid crashing if it does not get defined.  */
12870           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12871           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12872           TYPE_USER_ALIGN (ref) = 0;
12873           TREE_UNSIGNED (ref) = 1;
12874           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12875           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12876           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12877
12878           /* Enable us to recognize when a type is created in class context.
12879              To do nested classes correctly, this should probably be cleared
12880              out when we leave this classes scope.  Currently this in only
12881              done in `start_enum'.  */
12882
12883           pushtag (name, ref, globalize);
12884         }
12885       else
12886         {
12887           struct binding_level *old_b = class_binding_level;
12888
12889           ref = make_aggr_type (code);
12890           TYPE_CONTEXT (ref) = context;
12891
12892 #ifdef NONNESTED_CLASSES
12893           /* Class types don't nest the way enums do.  */
12894           class_binding_level = (struct binding_level *)0;
12895 #endif
12896           pushtag (name, ref, globalize);
12897           class_binding_level = old_b;
12898         }
12899     }
12900   else
12901     {
12902       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12903         redeclare_class_template (ref, current_template_parms);
12904     }
12905
12906   /* Until the type is defined, tentatively accept whatever
12907      structure tag the user hands us.  */
12908   if (!COMPLETE_TYPE_P (ref)
12909       && ref != current_class_type
12910       /* Have to check this, in case we have contradictory tag info.  */
12911       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12912     {
12913       if (tag_code == class_type)
12914         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12915       else if (tag_code == record_type)
12916         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12917     }
12918
12919   TREE_TYPE (ref) = attributes;
12920
12921   return ref;
12922 }
12923
12924 tree
12925 xref_tag_from_type (old, id, globalize)
12926      tree old, id;
12927      int globalize;
12928 {
12929   tree code_type_node;
12930
12931   if (TREE_CODE (old) == RECORD_TYPE)
12932     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12933                       ? class_type_node : record_type_node);
12934   else
12935     code_type_node = union_type_node;
12936
12937   if (id == NULL_TREE)
12938     id = TYPE_IDENTIFIER (old);
12939
12940   return xref_tag (code_type_node, id, globalize);
12941 }
12942
12943 /* REF is a type (named NAME), for which we have just seen some
12944    baseclasses.  BINFO is a list of those baseclasses; the
12945    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12946    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12947    struct, or union.  */
12948
12949 void
12950 xref_basetypes (code_type_node, name, ref, binfo)
12951      tree code_type_node;
12952      tree name, ref;
12953      tree binfo;
12954 {
12955   /* In the declaration `A : X, Y, ... Z' we mark all the types
12956      (A, X, Y, ..., Z) so we can check for duplicates.  */
12957   tree binfos;
12958   tree base;
12959
12960   int i, len;
12961   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12962
12963   if (tag_code == union_type)
12964     {
12965       cp_error ("derived union `%T' invalid", ref);
12966       return;
12967     }
12968
12969   len = list_length (binfo);
12970
12971   /* First, make sure that any templates in base-classes are
12972      instantiated.  This ensures that if we call ourselves recursively
12973      we do not get confused about which classes are marked and which
12974      are not.  */
12975   for (base = binfo; base; base = TREE_CHAIN (base))
12976     complete_type (TREE_VALUE (base));
12977
12978   SET_CLASSTYPE_MARKED (ref);
12979   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12980
12981   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12982     {
12983       /* The base of a derived struct is public by default.  */
12984       int via_public
12985         = (TREE_PURPOSE (binfo) == access_public_node
12986            || TREE_PURPOSE (binfo) == access_public_virtual_node
12987            || (tag_code != class_type
12988                && (TREE_PURPOSE (binfo) == access_default_node
12989                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12990       int via_protected
12991         = (TREE_PURPOSE (binfo) == access_protected_node
12992            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12993       int via_virtual
12994         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12995            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12996            || TREE_PURPOSE (binfo) == access_public_virtual_node
12997            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12998       tree basetype = TREE_VALUE (binfo);
12999       tree base_binfo;
13000
13001       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13002         basetype = TREE_TYPE (basetype);
13003       if (!basetype
13004           || (TREE_CODE (basetype) != RECORD_TYPE
13005               && TREE_CODE (basetype) != TYPENAME_TYPE
13006               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13007               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
13008         {
13009           cp_error ("base type `%T' fails to be a struct or class type",
13010                     TREE_VALUE (binfo));
13011           continue;
13012         }
13013
13014       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
13015
13016       /* This code replaces similar code in layout_basetypes.
13017          We put the complete_type first for implicit `typename'.  */
13018       if (!COMPLETE_TYPE_P (basetype)
13019           && ! (current_template_parms && uses_template_parms (basetype)))
13020         {
13021           cp_error ("base class `%T' has incomplete type", basetype);
13022           continue;
13023         }
13024       else
13025         {
13026           if (CLASSTYPE_MARKED (basetype))
13027             {
13028               if (basetype == ref)
13029                 cp_error ("recursive type `%T' undefined", basetype);
13030               else
13031                 cp_error ("duplicate base type `%T' invalid", basetype);
13032               continue;
13033             }
13034
13035           if (TYPE_FOR_JAVA (basetype)
13036               && (current_lang_stack
13037                   == &VARRAY_TREE (current_lang_base, 0)))
13038             TYPE_FOR_JAVA (ref) = 1;
13039
13040           /* Note that the BINFO records which describe individual
13041              inheritances are *not* shared in the lattice!  They
13042              cannot be shared because a given baseclass may be
13043              inherited with different `accessibility' by different
13044              derived classes.  (Each BINFO record describing an
13045              individual inheritance contains flags which say what
13046              the `accessibility' of that particular inheritance is.)  */
13047
13048           base_binfo
13049             = make_binfo (size_zero_node, basetype,
13050                           CLASS_TYPE_P (basetype)
13051                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13052                           CLASS_TYPE_P (basetype)
13053                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13054
13055           TREE_VEC_ELT (binfos, i) = base_binfo;
13056           TREE_VIA_PUBLIC (base_binfo) = via_public;
13057           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13058           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13059           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13060
13061           /* We need to unshare the binfos now so that lookups during class
13062              definition work.  */
13063           unshare_base_binfos (base_binfo);
13064
13065           SET_CLASSTYPE_MARKED (basetype);
13066
13067           /* We are free to modify these bits because they are meaningless
13068              at top level, and BASETYPE is a top-level type.  */
13069           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13070             {
13071               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13072               /* Converting to a virtual base class requires looking
13073                  up the offset of the virtual base.  */
13074               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13075             }
13076
13077           if (CLASS_TYPE_P (basetype))
13078             {
13079               TYPE_HAS_NEW_OPERATOR (ref)
13080                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13081               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13082                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13083               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13084               /* If the base-class uses multiple inheritance, so do we.  */
13085               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13086                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13087               /* Likewise, if converting to a base of the base may require
13088                  code, then we may need to generate code to convert to a
13089                  base as well.  */
13090               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13091                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13092             }
13093
13094           i += 1;
13095         }
13096     }
13097   if (i)
13098     TREE_VEC_LENGTH (binfos) = i;
13099   else
13100     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13101
13102   if (i > 1)
13103     {
13104       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13105       /* If there is more than one non-empty they cannot be at the same
13106          address.  */
13107       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13108     }
13109
13110   /* Unmark all the types.  */
13111   while (--i >= 0)
13112     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13113   CLEAR_CLASSTYPE_MARKED (ref);
13114
13115   /* Now that we know all the base-classes, set up the list of virtual
13116      bases.  */
13117   get_vbase_types (ref);
13118 }
13119
13120 \f
13121 /* Begin compiling the definition of an enumeration type.
13122    NAME is its name (or null if anonymous).
13123    Returns the type object, as yet incomplete.
13124    Also records info about it so that build_enumerator
13125    may be used to declare the individual values as they are read.  */
13126
13127 tree
13128 start_enum (name)
13129      tree name;
13130 {
13131   register tree enumtype = NULL_TREE;
13132   struct binding_level *b = current_binding_level;
13133
13134   /* If this is the real definition for a previous forward reference,
13135      fill in the contents in the same object that used to be the
13136      forward reference.  */
13137
13138   if (name != NULL_TREE)
13139     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13140
13141   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13142     {
13143       cp_error ("multiple definition of `%#T'", enumtype);
13144       cp_error_at ("previous definition here", enumtype);
13145       /* Clear out TYPE_VALUES, and start again.  */
13146       TYPE_VALUES (enumtype) = NULL_TREE;
13147     }
13148   else
13149     {
13150       enumtype = make_node (ENUMERAL_TYPE);
13151       pushtag (name, enumtype, 0);
13152     }
13153
13154   if (current_class_type)
13155     TREE_ADDRESSABLE (b->tags) = 1;
13156
13157   GNU_xref_decl (current_function_decl, enumtype);
13158   return enumtype;
13159 }
13160
13161 /* After processing and defining all the values of an enumeration type,
13162    install their decls in the enumeration type and finish it off.
13163    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13164    Returns ENUMTYPE.  */
13165
13166 tree
13167 finish_enum (enumtype)
13168      tree enumtype;
13169 {
13170   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13171   /* Calculate the maximum value of any enumerator in this type.  */
13172
13173   tree values = TYPE_VALUES (enumtype);
13174   if (values)
13175     {
13176       tree pair;
13177
13178       for (pair = values; pair; pair = TREE_CHAIN (pair))
13179         {
13180           tree decl;
13181           tree value;
13182
13183           /* The TREE_VALUE is a CONST_DECL for this enumeration
13184              constant.  */
13185           decl = TREE_VALUE (pair);
13186
13187           /* [dcl.enum]
13188
13189              Following the closing brace of an enum-specifier, each
13190              enumerator has the type of its enumeration.  Prior to the
13191              closing brace, the type of each enumerator is the type of
13192              its initializing value.  */
13193           TREE_TYPE (decl) = enumtype;
13194
13195           /* The DECL_INITIAL will be NULL if we are processing a
13196              template declaration and this enumeration constant had no
13197              explicit initializer.  */
13198           value = DECL_INITIAL (decl);
13199           if (value && !processing_template_decl)
13200             {
13201               /* Set the TREE_TYPE for the VALUE as well.  That's so
13202                  that when we call decl_constant_value we get an
13203                  entity of the right type (but with the constant
13204                  value).  Since we shouldn't ever call
13205                  decl_constant_value on a template type, there's no
13206                  reason to do that when processing_template_decl.
13207                  And, if the expression is something like a
13208                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13209                  wreak havoc on the intended type of the expression.
13210
13211                  Of course, there's also no point in trying to compute
13212                  minimum or maximum values if we're in a template.  */
13213               TREE_TYPE (value) = enumtype;
13214
13215               if (!minnode)
13216                 minnode = maxnode = value;
13217               else if (tree_int_cst_lt (maxnode, value))
13218                 maxnode = value;
13219               else if (tree_int_cst_lt (value, minnode))
13220                 minnode = value;
13221             }
13222
13223           if (processing_template_decl)
13224             /* If this is just a template, leave the CONST_DECL
13225                alone.  That way tsubst_copy will find CONST_DECLs for
13226                CONST_DECLs, and not INTEGER_CSTs.  */
13227             ;
13228           else
13229             /* In the list we're building up, we want the enumeration
13230                values, not the CONST_DECLs.  */
13231             TREE_VALUE (pair) = value;
13232         }
13233     }
13234   else
13235     maxnode = minnode = integer_zero_node;
13236
13237   TYPE_VALUES (enumtype) = nreverse (values);
13238
13239   if (processing_template_decl)
13240     {
13241       tree scope = current_scope ();
13242       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13243         add_tree (build_min (TAG_DEFN, enumtype));
13244     }
13245   else
13246     {
13247       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13248       int lowprec = min_precision (minnode, unsignedp);
13249       int highprec = min_precision (maxnode, unsignedp);
13250       int precision = MAX (lowprec, highprec);
13251       tree tem;
13252
13253       TYPE_SIZE (enumtype) = NULL_TREE;
13254
13255       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13256
13257       TYPE_PRECISION (enumtype) = precision;
13258       if (unsignedp)
13259         fixup_unsigned_type (enumtype);
13260       else
13261         fixup_signed_type (enumtype);
13262
13263       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13264         /* Use the width of the narrowest normal C type which is wide
13265            enough.  */
13266         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13267                                                     (precision, 1));
13268       else
13269         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13270
13271       TYPE_SIZE (enumtype) = 0;
13272       layout_type (enumtype);
13273
13274       /* Fix up all variant types of this enum type.  */
13275       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13276            tem = TYPE_NEXT_VARIANT (tem))
13277         {
13278           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13279           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13280           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13281           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13282           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13283           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13284           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13285           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13286           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13287           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13288         }
13289
13290       /* Finish debugging output for this type.  */
13291       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13292     }
13293
13294   return enumtype;
13295 }
13296
13297 /* Build and install a CONST_DECL for an enumeration constant of the
13298    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13299    Assignment of sequential values by default is handled here.  */
13300
13301 void
13302 build_enumerator (name, value, enumtype)
13303      tree name;
13304      tree value;
13305      tree enumtype;
13306 {
13307   tree decl;
13308   tree context;
13309   tree type;
13310   tree values;
13311
13312   /* Remove no-op casts from the value.  */
13313   if (value)
13314     STRIP_TYPE_NOPS (value);
13315
13316   if (! processing_template_decl)
13317     {
13318       /* Validate and default VALUE.  */
13319       if (value != NULL_TREE)
13320         {
13321           value = decl_constant_value (value);
13322
13323           if (TREE_CODE (value) == INTEGER_CST)
13324             {
13325               value = default_conversion (value);
13326               constant_expression_warning (value);
13327             }
13328           else
13329             {
13330               cp_error ("enumerator value for `%D' not integer constant", name);
13331               value = NULL_TREE;
13332             }
13333         }
13334
13335       /* Default based on previous value.  */
13336       if (value == NULL_TREE && ! processing_template_decl)
13337         {
13338           tree prev_value;
13339
13340           if (TYPE_VALUES (enumtype))
13341             {
13342               /* The next value is the previous value ... */
13343               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13344               /* ... plus one.  */
13345               value = cp_build_binary_op (PLUS_EXPR,
13346                                           prev_value,
13347                                           integer_one_node);
13348
13349               if (tree_int_cst_lt (value, prev_value))
13350                 cp_error ("overflow in enumeration values at `%D'", name);
13351             }
13352           else
13353             value = integer_zero_node;
13354         }
13355
13356       /* Remove no-op casts from the value.  */
13357       if (value)
13358         STRIP_TYPE_NOPS (value);
13359 #if 0
13360       /* To fix MAX_VAL enum consts. (bkoz)  */
13361       TREE_TYPE (value) = integer_type_node;
13362 #endif
13363     }
13364
13365   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13366      Even in other cases, we will later (in finish_enum) be setting
13367      the type of VALUE.  But, we don't need to make a copy if this
13368      VALUE is one of the enumeration constants for this same
13369      enumeration type.  */
13370   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13371     if (TREE_VALUE (values) == value)
13372       break;
13373   /* If we didn't break out of the loop, then we do need a copy.  */
13374   if (!values && value)
13375     value = copy_node (value);
13376
13377   /* C++ associates enums with global, function, or class declarations.  */
13378   context = current_scope ();
13379
13380   /* Build the actual enumeration constant.  Note that the enumeration
13381     constants have the type of their initializers until the
13382     enumeration is complete:
13383
13384       [ dcl.enum ]
13385
13386       Following the closing brace of an enum-specifier, each enumer-
13387       ator has the type of its enumeration.  Prior to the closing
13388       brace, the type of each enumerator is the type of its
13389       initializing value.
13390
13391     In finish_enum we will reset the type.  Of course, if we're
13392     processing a template, there may be no value.   */
13393   type = value ? TREE_TYPE (value) : NULL_TREE;
13394
13395   if (context && context == current_class_type)
13396     /* This enum declaration is local to the class.  We need the full
13397       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13398     decl = build_lang_decl (CONST_DECL, name, type);
13399   else
13400     /* It's a global enum, or it's local to a function.  (Note local to
13401       a function could mean local to a class method.  */
13402     decl = build_decl (CONST_DECL, name, type);
13403
13404   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13405   DECL_INITIAL (decl) = value;
13406   TREE_READONLY (decl) = 1;
13407
13408   if (context && context == current_class_type)
13409     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13410       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13411       things like `S::i' later.)  */
13412     finish_member_declaration (decl);
13413   else
13414     {
13415       pushdecl (decl);
13416       GNU_xref_decl (current_function_decl, decl);
13417     }
13418
13419   /* Add this enumeration constant to the list for this type.  */
13420   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13421 }
13422
13423 \f
13424 static int function_depth;
13425
13426 /* We're defining DECL.  Make sure that it's type is OK.  */
13427
13428 static void
13429 check_function_type (decl)
13430      tree decl;
13431 {
13432   tree fntype = TREE_TYPE (decl);
13433   tree return_type = complete_type (TREE_TYPE (fntype));
13434
13435   /* In a function definition, arg types must be complete.  */
13436   require_complete_types_for_parms (current_function_parms);
13437
13438   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13439     {
13440       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13441
13442       /* Make it return void instead, but don't change the
13443          type of the DECL_RESULT, in case we have a named return value.  */
13444       if (TREE_CODE (fntype) == METHOD_TYPE)
13445         {
13446           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13447           TREE_TYPE (decl)
13448             = build_cplus_method_type (ctype,
13449                                        void_type_node,
13450                                        FUNCTION_ARG_CHAIN (decl));
13451         }
13452       else
13453         TREE_TYPE (decl)
13454           = build_function_type (void_type_node,
13455                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13456       TREE_TYPE (decl)
13457         = build_exception_variant (fntype,
13458                                    TYPE_RAISES_EXCEPTIONS (fntype));
13459     }
13460   else
13461     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13462 }
13463
13464 /* Create the FUNCTION_DECL for a function definition.
13465    DECLSPECS and DECLARATOR are the parts of the declaration;
13466    they describe the function's name and the type it returns,
13467    but twisted together in a fashion that parallels the syntax of C.
13468
13469    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13470    DECLARATOR is really the DECL for the function we are about to
13471    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13472    indicating that the function is an inline defined in-class, and
13473    SF_EXPAND indicating that we should generate RTL for this
13474    function.
13475
13476    This function creates a binding context for the function body
13477    as well as setting up the FUNCTION_DECL in current_function_decl.
13478
13479    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13480    (it defines a datum instead), we return 0, which tells
13481    yyparse to report a parse error.
13482
13483    For C++, we must first check whether that datum makes any sense.
13484    For example, "class A local_a(1,2);" means that variable local_a
13485    is an aggregate of type A, which should have a constructor
13486    applied to it with the argument list [1, 2].  */
13487
13488 int
13489 start_function (declspecs, declarator, attrs, flags)
13490      tree declspecs, declarator, attrs;
13491      int flags;
13492 {
13493   tree decl1;
13494   tree ctype = NULL_TREE;
13495   tree fntype;
13496   tree restype;
13497   extern int have_extern_spec;
13498   extern int used_extern_spec;
13499   int doing_friend = 0;
13500   struct binding_level *bl;
13501
13502   /* Sanity check.  */
13503   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13504   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13505
13506   /* This should only be done once on the top most decl.  */
13507   if (have_extern_spec && !used_extern_spec)
13508     {
13509       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13510       used_extern_spec = 1;
13511     }
13512
13513   if (flags & SF_PRE_PARSED)
13514     {
13515       decl1 = declarator;
13516
13517       fntype = TREE_TYPE (decl1);
13518       if (TREE_CODE (fntype) == METHOD_TYPE)
13519         ctype = TYPE_METHOD_BASETYPE (fntype);
13520
13521       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13522          the (lexical) scope of the class in which it is defined.  */
13523       if (!ctype && DECL_FRIEND_P (decl1))
13524         {
13525           ctype = DECL_FRIEND_CONTEXT (decl1);
13526
13527           /* CTYPE could be null here if we're dealing with a template;
13528              for example, `inline friend float foo()' inside a template
13529              will have no CTYPE set.  */
13530           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13531             ctype = NULL_TREE;
13532           else
13533             doing_friend = 1;
13534         }
13535
13536       last_function_parms = DECL_ARGUMENTS (decl1);
13537       last_function_parm_tags = NULL_TREE;
13538     }
13539   else
13540     {
13541       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13542       /* If the declarator is not suitable for a function definition,
13543          cause a syntax error.  */
13544       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13545
13546       fntype = TREE_TYPE (decl1);
13547
13548       restype = TREE_TYPE (fntype);
13549       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13550         {
13551           cp_error ("semicolon missing after declaration of `%#T'", restype);
13552           shadow_tag (build_tree_list (NULL_TREE, restype));
13553           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13554           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13555             fntype = build_function_type (integer_type_node,
13556                                           TYPE_ARG_TYPES (fntype));
13557           else
13558             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13559                                               integer_type_node,
13560                                               TYPE_ARG_TYPES (fntype));
13561           TREE_TYPE (decl1) = fntype;
13562         }
13563
13564       if (TREE_CODE (fntype) == METHOD_TYPE)
13565         ctype = TYPE_METHOD_BASETYPE (fntype);
13566       else if (DECL_MAIN_P (decl1))
13567         {
13568           /* If this doesn't return integer_type, complain.  */
13569           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13570             {
13571               if (pedantic || warn_return_type)
13572                 pedwarn ("return type for `main' changed to `int'");
13573               TREE_TYPE (decl1) = fntype = default_function_type;
13574             }
13575         }
13576     }
13577
13578   /* Sometimes we don't notice that a function is a static member, and
13579      build a METHOD_TYPE for it.  Fix that up now.  */
13580   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13581       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13582     {
13583       revert_static_member_fn (decl1);
13584       last_function_parms = TREE_CHAIN (last_function_parms);
13585       ctype = NULL_TREE;
13586     }
13587
13588   /* Warn if function was previously implicitly declared
13589      (but not if we warned then).  */
13590   if (! warn_implicit
13591       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13592     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13593
13594   /* Set up current_class_type, and enter the scope of the class, if
13595      appropriate.  */
13596   if (ctype)
13597     push_nested_class (ctype, 1);
13598   else if (DECL_STATIC_FUNCTION_P (decl1))
13599     push_nested_class (DECL_CONTEXT (decl1), 2);
13600
13601   /* Now that we have entered the scope of the class, we must restore
13602      the bindings for any template parameters surrounding DECL1, if it
13603      is an inline member template.  (Order is important; consider the
13604      case where a template parameter has the same name as a field of
13605      the class.)  It is not until after this point that
13606      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13607   if (flags & SF_INCLASS_INLINE)
13608     maybe_begin_member_template_processing (decl1);
13609
13610   /* Effective C++ rule 15.  See also c_expand_return.  */
13611   if (warn_ecpp
13612       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13613       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13614     cp_warning ("`operator=' should return a reference to `*this'");
13615
13616   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13617      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13618   if (!DECL_INITIAL (decl1))
13619     DECL_INITIAL (decl1) = error_mark_node;
13620
13621 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13622   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13623 #endif
13624
13625   /* This function exists in static storage.
13626      (This does not mean `static' in the C sense!)  */
13627   TREE_STATIC (decl1) = 1;
13628
13629   /* We must call push_template_decl after current_class_type is set
13630      up.  (If we are processing inline definitions after exiting a
13631      class scope, current_class_type will be NULL_TREE until set above
13632      by push_nested_class.)  */
13633   if (processing_template_decl)
13634     decl1 = push_template_decl (decl1);
13635
13636   /* We are now in the scope of the function being defined.  */
13637   current_function_decl = decl1;
13638
13639   /* Save the parm names or decls from this function's declarator
13640      where store_parm_decls will find them.  */
13641   current_function_parms = last_function_parms;
13642   current_function_parm_tags = last_function_parm_tags;
13643
13644   /* Make sure the parameter and return types are reasonable.  When
13645      you declare a function, these types can be incomplete, but they
13646      must be complete when you define the function.  */
13647   if (! processing_template_decl)
13648     check_function_type (decl1);
13649
13650   /* Build the return declaration for the function.  */
13651   restype = TREE_TYPE (fntype);
13652   if (!processing_template_decl)
13653     {
13654       if (!DECL_RESULT (decl1))
13655         {
13656           DECL_RESULT (decl1)
13657             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13658           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13659                                       DECL_RESULT (decl1));
13660         }
13661     }
13662   else
13663     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13664     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13665
13666   /* Initialize RTL machinery.  We cannot do this until
13667      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13668      even when processing a template; this is how we get
13669      CFUN set up, and our per-function variables initialized.  */
13670   bl = current_binding_level;
13671   init_function_start (decl1, input_filename, lineno);
13672   current_binding_level = bl;
13673   expanding_p = (flags & SF_EXPAND) != 0;
13674
13675   /* Even though we're inside a function body, we still don't want to
13676      call expand_expr to calculate the size of a variable-sized array.
13677      We haven't necessarily assigned RTL to all variables yet, so it's
13678      not safe to try to expand expressions involving them.  */
13679   immediate_size_expand = 0;
13680   cfun->x_dont_save_pending_sizes_p = 1;
13681
13682   /* If we're building a statement-tree, start the tree now.  */
13683   if (processing_template_decl || !expanding_p)
13684     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13685
13686   /* Let the user know we're compiling this function.  */
13687   announce_function (decl1);
13688
13689   /* Record the decl so that the function name is defined.
13690      If we already have a decl for this name, and it is a FUNCTION_DECL,
13691      use the old decl.  */
13692   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13693     {
13694       /* A specialization is not used to guide overload resolution.  */
13695       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13696           && ! DECL_FUNCTION_MEMBER_P (decl1))
13697         decl1 = pushdecl (decl1);
13698       else
13699         {
13700           /* We need to set the DECL_CONTEXT. */
13701           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13702             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13703           /* And make sure we have enough default args.  */
13704           check_default_args (decl1);
13705         }
13706       fntype = TREE_TYPE (decl1);
13707     }
13708
13709   /* Reset these in case the call to pushdecl changed them.  */
13710   current_function_decl = decl1;
13711   cfun->decl = decl1;
13712
13713   /* Initialize the per-function data.  */
13714   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13715     {
13716       /* If we already parsed this function, and we're just expanding it
13717          now, restore saved state.  */
13718       struct binding_level *bl = current_binding_level;
13719       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13720       current_binding_level = bl;
13721
13722       /* This function is being processed in whole-function mode; we
13723          already did semantic analysis.  */
13724       cfun->x_whole_function_mode_p = 1;
13725
13726       /* If we decided that we didn't want to inline this function,
13727          make sure the back-end knows that.  */
13728       if (!current_function_cannot_inline)
13729         current_function_cannot_inline = cp_function_chain->cannot_inline;
13730
13731       /* We don't need the saved data anymore.  */
13732       free (DECL_SAVED_FUNCTION_DATA (decl1));
13733       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13734     }
13735   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13736     {
13737       /* We know that this was set up by `grokclassfn'.  We do not
13738          wait until `store_parm_decls', since evil parse errors may
13739          never get us to that point.  Here we keep the consistency
13740          between `current_class_type' and `current_class_ptr'.  */
13741       tree t = DECL_ARGUMENTS (decl1);
13742
13743       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13744                           162);
13745       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13746                           19990811);
13747
13748       cp_function_chain->x_current_class_ref
13749         = build_indirect_ref (t, NULL_PTR);
13750       cp_function_chain->x_current_class_ptr = t;
13751
13752       /* Constructors and destructors need to know whether they're "in
13753          charge" of initializing virtual base classes.  */
13754       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13755         current_in_charge_parm = TREE_CHAIN (t);
13756     }
13757
13758   if (DECL_INTERFACE_KNOWN (decl1))
13759     {
13760       tree ctx = decl_function_context (decl1);
13761
13762       if (DECL_NOT_REALLY_EXTERN (decl1))
13763         DECL_EXTERNAL (decl1) = 0;
13764
13765       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13766           && TREE_PUBLIC (ctx))
13767         /* This is a function in a local class in an extern inline
13768            function.  */
13769         comdat_linkage (decl1);
13770     }
13771   /* If this function belongs to an interface, it is public.
13772      If it belongs to someone else's interface, it is also external.
13773      This only affects inlines and template instantiations.  */
13774   else if (interface_unknown == 0
13775            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13776                || flag_alt_external_templates))
13777     {
13778       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13779           || processing_template_decl)
13780         {
13781           DECL_EXTERNAL (decl1)
13782             = (interface_only
13783                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13784                    && !DECL_VINDEX (decl1)));
13785
13786           /* For WIN32 we also want to put these in linkonce sections.  */
13787           maybe_make_one_only (decl1);
13788         }
13789       else
13790         DECL_EXTERNAL (decl1) = 0;
13791       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13792       DECL_INTERFACE_KNOWN (decl1) = 1;
13793     }
13794   else if (interface_unknown && interface_only
13795            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13796                || flag_alt_external_templates))
13797     {
13798       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13799          interface, we will have interface_only set but not
13800          interface_known.  In that case, we don't want to use the normal
13801          heuristics because someone will supply a #pragma implementation
13802          elsewhere, and deducing it here would produce a conflict.  */
13803       comdat_linkage (decl1);
13804       DECL_EXTERNAL (decl1) = 0;
13805       DECL_INTERFACE_KNOWN (decl1) = 1;
13806       DECL_DEFER_OUTPUT (decl1) = 1;
13807     }
13808   else
13809     {
13810       /* This is a definition, not a reference.
13811          So clear DECL_EXTERNAL.  */
13812       DECL_EXTERNAL (decl1) = 0;
13813
13814       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13815           && ! DECL_INTERFACE_KNOWN (decl1)
13816           /* Don't try to defer nested functions for now.  */
13817           && ! decl_function_context (decl1))
13818         DECL_DEFER_OUTPUT (decl1) = 1;
13819       else
13820         DECL_INTERFACE_KNOWN (decl1) = 1;
13821     }
13822
13823   if (doing_semantic_analysis_p ())
13824     {
13825       pushlevel (0);
13826       current_binding_level->parm_flag = 1;
13827     }
13828
13829   if (attrs)
13830     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13831
13832   if (!building_stmt_tree ())
13833     {
13834       GNU_xref_function (decl1, current_function_parms);
13835       make_function_rtl (decl1);
13836     }
13837
13838   /* Promote the value to int before returning it.  */
13839   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13840     restype = type_promotes_to (restype);
13841
13842   /* If this fcn was already referenced via a block-scope `extern' decl
13843      (or an implicit decl), propagate certain information about the usage.  */
13844   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13845     TREE_ADDRESSABLE (decl1) = 1;
13846
13847   if (DECL_RESULT (decl1) == NULL_TREE)
13848     {
13849       DECL_RESULT (decl1)
13850         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13851       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13852       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13853     }
13854
13855   ++function_depth;
13856
13857   if (DECL_DESTRUCTOR_P (decl1))
13858     {
13859       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13860       DECL_CONTEXT (dtor_label) = current_function_decl;
13861     }
13862   /* Under the old ABI we return `this' from constructors, so we make
13863      ordinary `return' statements in constructors jump to CTOR_LABEL;
13864      from there we return `this'.  Under the new ABI, we don't bother
13865      with any of this.  By not setting CTOR_LABEL the remainder of the
13866      machinery is automatically disabled.  */
13867   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13868     {
13869       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13870       DECL_CONTEXT (ctor_label) = current_function_decl;
13871     }
13872
13873   return 1;
13874 }
13875 \f
13876 /* Called after store_parm_decls for a function-try-block.  */
13877
13878 void
13879 expand_start_early_try_stmts ()
13880 {
13881   expand_start_try_stmts ();
13882 }
13883
13884 /* Store the parameter declarations into the current function declaration.
13885    This is called after parsing the parameter declarations, before
13886    digesting the body of the function.
13887
13888    Also install to binding contour return value identifier, if any.  */
13889
13890 void
13891 store_parm_decls ()
13892 {
13893   register tree fndecl = current_function_decl;
13894   register tree parm;
13895   int parms_have_cleanups = 0;
13896   tree cleanups = NULL_TREE;
13897
13898   /* This is a list of types declared among parms in a prototype.  */
13899   tree parmtags = current_function_parm_tags;
13900
13901   /* This is a chain of any other decls that came in among the parm
13902      declarations.  If a parm is declared with  enum {foo, bar} x;
13903      then CONST_DECLs for foo and bar are put here.  */
13904   tree nonparms = NULL_TREE;
13905
13906   /* Create a binding level for the parms.  */
13907   if (!building_stmt_tree ())
13908     expand_start_bindings (2);
13909
13910   if (current_function_parms)
13911     {
13912       /* This case is when the function was defined with an ANSI prototype.
13913          The parms already have decls, so we need not do anything here
13914          except record them as in effect
13915          and complain if any redundant old-style parm decls were written.  */
13916
13917       tree specparms = current_function_parms;
13918       tree next;
13919
13920       if (doing_semantic_analysis_p ())
13921         {
13922           /* Must clear this because it might contain TYPE_DECLs declared
13923              at class level.  */
13924           storedecls (NULL_TREE);
13925
13926           /* If we're doing semantic analysis, then we'll call pushdecl
13927              for each of these.  We must do them in reverse order so that
13928              they end in the correct forward order.  */
13929           specparms = nreverse (specparms);
13930         }
13931
13932       for (parm = specparms; parm; parm = next)
13933         {
13934           next = TREE_CHAIN (parm);
13935           if (TREE_CODE (parm) == PARM_DECL)
13936             {
13937               tree type = TREE_TYPE (parm);
13938
13939               if (doing_semantic_analysis_p ())
13940                 {
13941                   tree cleanup;
13942
13943                   if (DECL_NAME (parm) == NULL_TREE
13944                       || TREE_CODE (parm) != VOID_TYPE)
13945                     pushdecl (parm);
13946                   else
13947                     cp_error ("parameter `%D' declared void", parm);
13948
13949                   cleanup = (processing_template_decl
13950                              ? NULL_TREE
13951                              : maybe_build_cleanup (parm));
13952
13953                   if (cleanup)
13954                     cleanups = tree_cons (parm, cleanup, cleanups);
13955                 }
13956               else if (type != error_mark_node
13957                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13958                 parms_have_cleanups = 1;
13959             }
13960           else
13961             {
13962               /* If we find an enum constant or a type tag,
13963                  put it aside for the moment.  */
13964               TREE_CHAIN (parm) = NULL_TREE;
13965               nonparms = chainon (nonparms, parm);
13966             }
13967         }
13968
13969       if (doing_semantic_analysis_p ())
13970         {
13971           /* Get the decls in their original chain order
13972              and record in the function.  This is all and only the
13973              PARM_DECLs that were pushed into scope by the loop above.  */
13974           DECL_ARGUMENTS (fndecl) = getdecls ();
13975           storetags (chainon (parmtags, gettags ()));
13976         }
13977     }
13978   else
13979     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13980
13981   /* Now store the final chain of decls for the arguments
13982      as the decl-chain of the current lexical scope.
13983      Put the enumerators in as well, at the front so that
13984      DECL_ARGUMENTS is not modified.  */
13985   if (doing_semantic_analysis_p ())
13986     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13987
13988   /* Initialize the RTL code for the function.  */
13989   DECL_SAVED_INSNS (fndecl) = 0;
13990   if (! building_stmt_tree ())
13991     expand_function_start (fndecl, parms_have_cleanups);
13992
13993   current_function_parms_stored = 1;
13994
13995   /* If this function is `main', emit a call to `__main'
13996      to run global initializers, etc.  */
13997   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13998     expand_main_function ();
13999
14000   /* Now that we have initialized the parms, we can start their
14001      cleanups.  We cannot do this before, since expand_decl_cleanup
14002      should not be called before the parm can be used.  */
14003   while (cleanups)
14004     {
14005       finish_decl_cleanup (TREE_PURPOSE (cleanups),
14006                            TREE_VALUE (cleanups));
14007       cleanups = TREE_CHAIN (cleanups);
14008     }
14009
14010   /* Create a binding contour which can be used to catch
14011      cleanup-generated temporaries.  Also, if the return value needs or
14012      has initialization, deal with that now.  */
14013   if (parms_have_cleanups)
14014     {
14015       pushlevel (0);
14016       if (!building_stmt_tree ())
14017         expand_start_bindings (2);
14018     }
14019
14020   /* Do the starting of the exception specifications, if we have any.  */
14021   if (flag_exceptions && !processing_template_decl
14022       && flag_enforce_eh_specs
14023       && building_stmt_tree ()
14024       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14025     current_eh_spec_try_block = expand_start_eh_spec ();
14026 }
14027
14028 /* Bind a name and initialization to the return value of
14029    the current function.  */
14030
14031 void
14032 store_return_init (decl)
14033      tree decl;
14034 {
14035   /* If this named return value comes in a register, put it in a
14036      pseudo-register.  */
14037   if (DECL_REGISTER (decl))
14038     {
14039       original_result_rtx = DECL_RTL (decl);
14040       /* Note that the mode of the old DECL_RTL may be wider than the
14041          mode of DECL_RESULT, depending on the calling conventions for
14042          the processor.  For example, on the Alpha, a 32-bit integer
14043          is returned in a DImode register -- the DECL_RESULT has
14044          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
14045          here, we use the mode the back-end has already assigned for
14046          the return value.  */
14047       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
14048       if (TREE_ADDRESSABLE (decl))
14049         put_var_into_stack (decl);
14050     }
14051 }
14052
14053 \f
14054 /* We have finished doing semantic analysis on DECL, but have not yet
14055    generated RTL for its body.  Save away our current state, so that
14056    when we want to generate RTL later we know what to do.  */
14057
14058 static void
14059 save_function_data (decl)
14060      tree decl;
14061 {
14062   struct language_function *f;
14063
14064   /* Save the language-specific per-function data so that we can
14065      get it back when we really expand this function.  */
14066   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14067                       19990908);
14068
14069   /* Make a copy.  */
14070   f = ((struct language_function *)
14071        xmalloc (sizeof (struct language_function)));
14072   bcopy ((char *) cp_function_chain, (char *) f,
14073          sizeof (struct language_function));
14074   DECL_SAVED_FUNCTION_DATA (decl) = f;
14075
14076   /* Clear out the bits we don't need.  */
14077   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14078   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14079   f->x_result_rtx = NULL_RTX;
14080   f->x_named_label_uses = NULL;
14081   f->bindings = NULL;
14082
14083   /* When we get back here again, we will be expanding.  */
14084   f->x_expanding_p = 1;
14085
14086   /* If we've already decided that we cannot inline this function, we
14087      must remember that fact when we actually go to expand the
14088      function.  */
14089   f->cannot_inline = current_function_cannot_inline;
14090 }
14091
14092 /* At the end of every constructor we generate to code to return
14093    `this'.  Do that now.  */
14094
14095 static void
14096 finish_constructor_body ()
14097 {
14098   /* Any return from a constructor will end up here.  */
14099   if (ctor_label)
14100     add_tree (build_min_nt (LABEL_STMT, ctor_label));
14101
14102   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14103      generate the return, rather than a goto to CTOR_LABEL.  */
14104   ctor_label = NULL_TREE;
14105   /* In check_return_expr we translate an empty return from a
14106      constructor to a return of `this'.  */
14107   finish_return_stmt (NULL_TREE);
14108   /* Mark the end of the constructor.  */
14109   add_tree (build_min_nt (CTOR_STMT));
14110 }
14111
14112 /* At the end of every destructor we generate code to restore virtual
14113    function tables to the values desired by base classes and to call
14114    to base class destructors.  Do that now.  */
14115
14116 static void
14117 finish_destructor_body ()
14118 {
14119   tree compound_stmt;
14120   tree virtual_size;
14121   tree exprstmt;
14122   tree if_stmt;
14123
14124   /* Create a block to contain all the extra code.  */
14125   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14126
14127   /* Any return from a destructor will end up here.  */
14128   add_tree (build_min_nt (LABEL_STMT, dtor_label));
14129
14130   /* Generate the code to call destructor on base class.  If this
14131      destructor belongs to a class with virtual functions, then set
14132      the virtual function table pointer to represent the type of our
14133      base class.  */
14134
14135   /* This side-effect makes call to `build_delete' generate the code
14136      we have to have at the end of this destructor.  `build_delete'
14137      will set the flag again.  */
14138   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14139
14140   exprstmt = build_delete (current_class_type,
14141                            current_class_ref,
14142                            sfk_base_destructor,
14143                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14144                            0);
14145
14146   if (exprstmt != error_mark_node
14147       && (TREE_CODE (exprstmt) != NOP_EXPR
14148           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14149           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14150     {
14151       if (exprstmt != void_zero_node)
14152         /* Don't call `expand_expr_stmt' if we're not going to do
14153            anything, since -Wall will give a diagnostic.  */
14154         finish_expr_stmt (exprstmt);
14155
14156       /* Run destructors for all virtual baseclasses.  */
14157       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14158         {
14159           tree vbases;
14160           tree if_stmt;
14161
14162           if_stmt = begin_if_stmt ();
14163           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14164                                       current_in_charge_parm,
14165                                       integer_two_node),
14166                                if_stmt);
14167
14168           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14169           /* The CLASSTYPE_VBASECLASSES list is in initialization
14170              order, so we have to march through it in reverse order.  */
14171           for (vbases = nreverse (copy_list (vbases));
14172                vbases;
14173                vbases = TREE_CHAIN (vbases))
14174             {
14175               tree vbase = TREE_VALUE (vbases);
14176
14177               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14178                 {
14179                   tree vb = get_vbase
14180                     (BINFO_TYPE (vbase),
14181                      TYPE_BINFO (current_class_type));
14182                   finish_expr_stmt
14183                     (build_scoped_method_call
14184                      (current_class_ref, vb, base_dtor_identifier,
14185                       NULL_TREE));
14186                 }
14187             }
14188
14189           finish_then_clause (if_stmt);
14190           finish_if_stmt ();
14191         }
14192     }
14193
14194   virtual_size = c_sizeof (current_class_type);
14195
14196   /* At the end, call delete if that's what's requested.  */
14197
14198   /* FDIS sez: At the point of definition of a virtual destructor
14199      (including an implicit definition), non-placement operator delete
14200      shall be looked up in the scope of the destructor's class and if
14201      found shall be accessible and unambiguous.
14202
14203      This is somewhat unclear, but I take it to mean that if the class
14204      only defines placement deletes we don't do anything here.  So we
14205      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14206      they ever try to delete one of these.  */
14207   exprstmt = build_op_delete_call
14208     (DELETE_EXPR, current_class_ptr, virtual_size,
14209      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14210
14211   if_stmt = begin_if_stmt ();
14212   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14213                               current_in_charge_parm,
14214                               integer_one_node),
14215                        if_stmt);
14216   finish_expr_stmt (exprstmt);
14217   finish_then_clause (if_stmt);
14218   finish_if_stmt ();
14219
14220   /* Close the block we started above.  */
14221   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14222 }
14223
14224 /* Finish up a function declaration and compile that function
14225    all the way to assembler language output.  The free the storage
14226    for the function definition.
14227
14228    FLAGS is a bitwise or of the following values:
14229      1 - CALL_POPLEVEL
14230        An extra call to poplevel (and expand_end_bindings) must be
14231        made to take care of the binding contour for the base
14232        initializers.  This is only relevant for constructors.
14233      2 - INCLASS_INLINE
14234        We just finished processing the body of an in-class inline
14235        function definition.  (This processing will have taken place
14236        after the class definition is complete.)  */
14237
14238 tree
14239 finish_function (flags)
14240      int flags;
14241 {
14242   register tree fndecl = current_function_decl;
14243   tree fntype, ctype = NULL_TREE;
14244   /* Label to use if this function is supposed to return a value.  */
14245   tree no_return_label = NULL_TREE;
14246   int call_poplevel = (flags & 1) != 0;
14247   int inclass_inline = (flags & 2) != 0;
14248   int expand_p;
14249   int nested;
14250   int current_line = lineno;
14251
14252   /* When we get some parse errors, we can end up without a
14253      current_function_decl, so cope.  */
14254   if (fndecl == NULL_TREE)
14255     return error_mark_node;
14256
14257   nested = function_depth > 1;
14258   fntype = TREE_TYPE (fndecl);
14259
14260   /*  TREE_READONLY (fndecl) = 1;
14261       This caused &foo to be of type ptr-to-const-function
14262       which then got a warning when stored in a ptr-to-function variable.  */
14263
14264   /* This happens on strange parse errors.  */
14265   if (! current_function_parms_stored)
14266     {
14267       call_poplevel = 0;
14268       store_parm_decls ();
14269     }
14270
14271   /* For a cloned function, we've already got all the code we need;
14272      there's no need to add any extra bits.  */
14273   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14274     ;
14275   else if (building_stmt_tree ())
14276     {
14277       if (DECL_CONSTRUCTOR_P (fndecl))
14278         {
14279           finish_constructor_body ();
14280           if (call_poplevel)
14281             do_poplevel ();
14282         }
14283       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14284         finish_destructor_body ();
14285       else if (DECL_MAIN_P (fndecl))
14286         {
14287           /* Make it so that `main' always returns 0 by default.  */
14288 #ifdef VMS
14289           finish_return_stmt (integer_one_node);
14290 #else
14291           finish_return_stmt (integer_zero_node);
14292 #endif
14293         }
14294
14295       /* Finish dealing with exception specifiers.  */
14296       if (flag_exceptions && !processing_template_decl
14297           && flag_enforce_eh_specs
14298           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14299         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14300                             (TREE_TYPE (current_function_decl)),
14301                             current_eh_spec_try_block);
14302     }
14303   else
14304     {
14305 #if 0
14306       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14307         {
14308           /* Keep this code around in case we later want to control debug info
14309              based on whether a type is "used".  (jason 1999-11-11) */
14310
14311           tree ttype = target_type (fntype);
14312           tree parmdecl;
14313
14314           if (IS_AGGR_TYPE (ttype))
14315             /* Let debugger know it should output info for this type.  */
14316             note_debug_info_needed (ttype);
14317
14318           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14319             {
14320               ttype = target_type (TREE_TYPE (parmdecl));
14321               if (IS_AGGR_TYPE (ttype))
14322                 /* Let debugger know it should output info for this type.  */
14323                 note_debug_info_needed (ttype);
14324             }
14325         }
14326 #endif
14327
14328       /* Clean house because we will need to reorder insns here.  */
14329       do_pending_stack_adjust ();
14330
14331       if (dtor_label)
14332         ;
14333       else if (DECL_CONSTRUCTOR_P (fndecl))
14334         {
14335           if (call_poplevel)
14336             do_poplevel ();
14337         }
14338       else if (return_label != NULL_RTX
14339                && flag_this_is_variable <= 0
14340                && current_function_return_value == NULL_TREE
14341                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14342         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14343
14344       if (flag_exceptions)
14345         expand_exception_blocks ();
14346
14347       /* If this function is supposed to return a value, ensure that
14348          we do not fall into the cleanups by mistake.  The end of our
14349          function will look like this:
14350
14351          user code (may have return stmt somewhere)
14352          goto no_return_label
14353          cleanup_label:
14354          cleanups
14355          goto return_label
14356          no_return_label:
14357          NOTE_INSN_FUNCTION_END
14358          return_label:
14359          things for return
14360
14361          If the user omits a return stmt in the USER CODE section, we
14362          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14363          Otherwise, we won't.  */
14364       if (no_return_label)
14365         {
14366           DECL_CONTEXT (no_return_label) = fndecl;
14367           DECL_INITIAL (no_return_label) = error_mark_node;
14368           DECL_SOURCE_FILE (no_return_label) = input_filename;
14369           DECL_SOURCE_LINE (no_return_label) = current_line;
14370           expand_goto (no_return_label);
14371         }
14372
14373       if (cleanup_label)
14374         {
14375           /* Remove the binding contour which is used
14376              to catch cleanup-generated temporaries.  */
14377           expand_end_bindings (0, 0, 0);
14378           poplevel (0, 0, 0);
14379
14380           /* Emit label at beginning of cleanup code for parameters.  */
14381           emit_label (cleanup_label);
14382         }
14383
14384       /* Get return value into register if that's where it's supposed
14385          to be.  */
14386       if (original_result_rtx)
14387         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14388
14389       /* Finish building code that will trigger warnings if users forget
14390          to make their functions return values.  */
14391       if (no_return_label || cleanup_label)
14392         emit_jump (return_label);
14393       if (no_return_label)
14394         {
14395           /* We don't need to call `expand_*_return' here because we
14396              don't need any cleanups here--this path of code is only
14397              for error checking purposes.  */
14398           expand_label (no_return_label);
14399         }
14400
14401       /* We hard-wired immediate_size_expand to zero in
14402          start_function.  Expand_function_end will decrement this
14403          variable.  So, we set the variable to one here, so that after
14404          the decrement it will remain zero.  */
14405       immediate_size_expand = 1;
14406
14407       /* Generate rtl for function exit.  */
14408       expand_function_end (input_filename, current_line, 1);
14409     }
14410
14411   /* We have to save this value here in case
14412      maybe_end_member_template_processing decides to pop all the
14413      template parameters.  */
14414   expand_p = !building_stmt_tree ();
14415
14416   /* If we're saving up tree structure, tie off the function now.  */
14417   if (!expand_p)
14418     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14419
14420   /* This must come after expand_function_end because cleanups might
14421      have declarations (from inline functions) that need to go into
14422      this function's blocks.  */
14423   if (doing_semantic_analysis_p ())
14424     {
14425       if (current_binding_level->parm_flag != 1)
14426         my_friendly_abort (122);
14427       poplevel (1, 0, 1);
14428     }
14429
14430   /* Remember that we were in class scope.  */
14431   if (current_class_name)
14432     ctype = current_class_type;
14433
14434   /* Must mark the RESULT_DECL as being in this function.  */
14435   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14436
14437   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14438      to the FUNCTION_DECL node itself.  */
14439   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14440
14441   /* Save away current state, if appropriate.  */
14442   if (!expanding_p && !processing_template_decl)
14443     save_function_data (fndecl);
14444
14445   /* If this function calls `setjmp' it cannot be inlined.  When
14446      `longjmp' is called it is not guaranteed to restore the value of
14447      local variables that have been modified since the call to
14448      `setjmp'.  So, if were to inline this function into some caller
14449      `c', then when we `longjmp', we might not restore all variables
14450      in `c'.  (It might seem, at first blush, that there's no way for
14451      this function to modify local variables in `c', but their
14452      addresses may have been stored somewhere accessible to this
14453      function.)  */
14454   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14455     DECL_UNINLINABLE (fndecl) = 1;
14456
14457   if (expand_p)
14458     {
14459       int returns_null;
14460       int returns_value;
14461
14462       /* So we can tell if jump_optimize sets it to 1.  */
14463       can_reach_end = 0;
14464
14465       /* Before we call rest_of_compilation (which will pop the
14466          CURRENT_FUNCTION), we must save these values.  */
14467       returns_null = current_function_returns_null;
14468       returns_value = current_function_returns_value;
14469
14470       /* If this is a nested function (like a template instantiation
14471          that we're compiling in the midst of compiling something
14472          else), push a new GC context.  That will keep local variables
14473          on the stack from being collected while we're doing the
14474          compilation of this function.  */
14475       if (function_depth > 1)
14476         ggc_push_context ();
14477
14478       /* Run the optimizers and output the assembler code for this
14479          function.  */
14480       rest_of_compilation (fndecl);
14481
14482       /* Undo the call to ggc_push_context above.  */
14483       if (function_depth > 1)
14484         ggc_pop_context ();
14485
14486       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14487         {
14488           /* Set DECL_EXTERNAL so that assemble_external will be called as
14489              necessary.  We'll clear it again in finish_file.  */
14490           if (! DECL_EXTERNAL (fndecl))
14491             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14492           DECL_EXTERNAL (fndecl) = 1;
14493           defer_fn (fndecl);
14494         }
14495
14496 #if 0
14497       /* Keep this code around in case we later want to control debug info
14498          based on whether a type is "used".  (jason 1999-11-11) */
14499
14500       if (ctype && TREE_ASM_WRITTEN (fndecl))
14501         note_debug_info_needed (ctype);
14502 #endif
14503
14504       if (DECL_NAME (DECL_RESULT (fndecl)))
14505         returns_value |= can_reach_end;
14506       else
14507         returns_null |= can_reach_end;
14508
14509       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14510         warning ("`noreturn' function does return");
14511       else if (returns_null
14512                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14513         {
14514           /* Always complain if there's just no return statement.  */
14515           if (!returns_value)
14516             warning ("no return statement in function returning non-void");
14517           else if (warn_return_type || pedantic)
14518             /* If this function returns non-void and control can drop through,
14519                complain.  */
14520             warning ("control reaches end of non-void function");
14521         }
14522     }
14523   else
14524     {
14525       /* Clear out memory we no longer need.  */
14526       free_after_parsing (cfun);
14527       /* Since we never call rest_of_compilation, we never clear
14528          CFUN.  Do so explicitly.  */
14529       free_after_compilation (cfun);
14530       cfun = NULL;
14531     }
14532
14533   /* If this is a in-class inline definition, we may have to pop the
14534      bindings for the template parameters that we added in
14535      maybe_begin_member_template_processing when start_function was
14536      called.  */
14537   if (inclass_inline)
14538     maybe_end_member_template_processing ();
14539
14540   /* Leave the scope of the class.  */
14541   if (ctype)
14542     pop_nested_class ();
14543
14544   --function_depth;
14545
14546   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14547       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14548     {
14549       tree t;
14550
14551       /* Stop pointing to the local nodes about to be freed.  */
14552       /* But DECL_INITIAL must remain nonzero so we know this
14553          was an actual function definition.  */
14554       DECL_INITIAL (fndecl) = error_mark_node;
14555       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14556         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14557     }
14558
14559   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14560     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14561   if (DECL_STATIC_DESTRUCTOR (fndecl))
14562     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14563
14564   /* Clean up.  */
14565   if (! nested)
14566     {
14567       /* Let the error reporting routines know that we're outside a
14568          function.  For a nested function, this value is used in
14569          pop_cp_function_context and then reset via pop_function_context.  */
14570       current_function_decl = NULL_TREE;
14571       /* We don't really care about obstacks, but the middle-end
14572          sometimes cares on what obstck things are located.  */
14573       permanent_allocation (1);
14574     }
14575
14576   return fndecl;
14577 }
14578 \f
14579 /* Create the FUNCTION_DECL for a function definition.
14580    DECLSPECS and DECLARATOR are the parts of the declaration;
14581    they describe the return type and the name of the function,
14582    but twisted together in a fashion that parallels the syntax of C.
14583
14584    This function creates a binding context for the function body
14585    as well as setting up the FUNCTION_DECL in current_function_decl.
14586
14587    Returns a FUNCTION_DECL on success.
14588
14589    If the DECLARATOR is not suitable for a function (it defines a datum
14590    instead), we return 0, which tells yyparse to report a parse error.
14591
14592    May return void_type_node indicating that this method is actually
14593    a friend.  See grokfield for more details.
14594
14595    Came here with a `.pushlevel' .
14596
14597    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14598    CHANGES TO CODE IN `grokfield'.  */
14599
14600 tree
14601 start_method (declspecs, declarator, attrlist)
14602      tree declarator, declspecs, attrlist;
14603 {
14604   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14605                                 attrlist);
14606
14607   /* Something too ugly to handle.  */
14608   if (fndecl == NULL_TREE)
14609     return NULL_TREE;
14610
14611   /* Pass friends other than inline friend functions back.  */
14612   if (fndecl == void_type_node)
14613     return fndecl;
14614
14615   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14616     /* Not a function, tell parser to report parse error.  */
14617     return NULL_TREE;
14618
14619   if (DECL_IN_AGGR_P (fndecl))
14620     {
14621       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14622         {
14623           if (DECL_CONTEXT (fndecl)
14624               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14625             cp_error ("`%D' is already defined in class %s", fndecl,
14626                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14627         }
14628       return void_type_node;
14629     }
14630
14631   check_template_shadow (fndecl);
14632
14633   DECL_THIS_INLINE (fndecl) = 1;
14634
14635   if (flag_default_inline)
14636     DECL_INLINE (fndecl) = 1;
14637
14638   /* We process method specializations in finish_struct_1.  */
14639   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14640     fndecl = push_template_decl (fndecl);
14641
14642   if (! DECL_FRIEND_P (fndecl))
14643     {
14644       if (TREE_CHAIN (fndecl))
14645         {
14646           fndecl = copy_node (fndecl);
14647           TREE_CHAIN (fndecl) = NULL_TREE;
14648         }
14649
14650       if (DECL_CONSTRUCTOR_P (fndecl))
14651         {
14652           if (! grok_ctor_properties (current_class_type, fndecl))
14653             return void_type_node;
14654         }
14655       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14656         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14657     }
14658
14659   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14660
14661   /* Make a place for the parms */
14662   pushlevel (0);
14663   current_binding_level->parm_flag = 1;
14664
14665   DECL_IN_AGGR_P (fndecl) = 1;
14666   return fndecl;
14667 }
14668
14669 /* Go through the motions of finishing a function definition.
14670    We don't compile this method until after the whole class has
14671    been processed.
14672
14673    FINISH_METHOD must return something that looks as though it
14674    came from GROKFIELD (since we are defining a method, after all).
14675
14676    This is called after parsing the body of the function definition.
14677    STMTS is the chain of statements that makes up the function body.
14678
14679    DECL is the ..._DECL that `start_method' provided.  */
14680
14681 tree
14682 finish_method (decl)
14683      tree decl;
14684 {
14685   register tree fndecl = decl;
14686   tree old_initial;
14687
14688   register tree link;
14689
14690   if (decl == void_type_node)
14691     return decl;
14692
14693   old_initial = DECL_INITIAL (fndecl);
14694
14695   /* Undo the level for the parms (from start_method).
14696      This is like poplevel, but it causes nothing to be
14697      saved.  Saving information here confuses symbol-table
14698      output routines.  Besides, this information will
14699      be correctly output when this method is actually
14700      compiled.  */
14701
14702   /* Clear out the meanings of the local variables of this level;
14703      also record in each decl which block it belongs to.  */
14704
14705   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14706     {
14707       if (DECL_NAME (link) != NULL_TREE)
14708         pop_binding (DECL_NAME (link), link);
14709       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14710       DECL_CONTEXT (link) = NULL_TREE;
14711     }
14712
14713   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14714                       (HOST_WIDE_INT) current_binding_level->level_chain,
14715                       current_binding_level->parm_flag,
14716                       current_binding_level->keep);
14717
14718   poplevel (0, 0, 0);
14719
14720   DECL_INITIAL (fndecl) = old_initial;
14721
14722   /* We used to check if the context of FNDECL was different from
14723      current_class_type as another way to get inside here.  This didn't work
14724      for String.cc in libg++.  */
14725   if (DECL_FRIEND_P (fndecl))
14726     {
14727       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14728         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14729       decl = void_type_node;
14730     }
14731
14732   return decl;
14733 }
14734 \f
14735 /* Called when a new struct TYPE is defined.
14736    If this structure or union completes the type of any previous
14737    variable declaration, lay it out and output its rtl.  */
14738
14739 void
14740 hack_incomplete_structures (type)
14741      tree type;
14742 {
14743   tree *list;
14744   struct binding_level *level;
14745
14746   if (!type) /* Don't do this for class templates.  */
14747     return;
14748
14749   if (namespace_bindings_p ())
14750     {
14751       level = 0;
14752       list = &namespace_scope_incomplete;
14753     }
14754   else
14755     {
14756       level = innermost_nonclass_level ();
14757       list = &level->incomplete;
14758     }
14759
14760   while (1)
14761     {
14762       while (*list)
14763         {
14764           tree decl = TREE_VALUE (*list);
14765           if ((decl && TREE_TYPE (decl) == type)
14766               || (TREE_TYPE (decl)
14767                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14768                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14769             {
14770               int toplevel = toplevel_bindings_p ();
14771               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14772                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14773                 layout_type (TREE_TYPE (decl));
14774               layout_decl (decl, 0);
14775               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14776               if (! toplevel)
14777                 {
14778                   tree cleanup;
14779                   expand_decl (decl);
14780                   cleanup = maybe_build_cleanup (decl);
14781                   expand_decl_init (decl);
14782                   if (! expand_decl_cleanup (decl, cleanup))
14783                     cp_error ("parser lost in parsing declaration of `%D'",
14784                               decl);
14785                 }
14786               *list = TREE_CHAIN (*list);
14787             }
14788           else
14789             list = &TREE_CHAIN (*list);
14790         }
14791
14792       /* Keep looking through artificial binding levels generated
14793          for local variables.  */
14794       if (level && level->keep == 2)
14795         {
14796           level = level->level_chain;
14797           list = &level->incomplete;
14798         }
14799       else
14800         break;
14801     }
14802 }
14803
14804 /* If DECL is of a type which needs a cleanup, build that cleanup
14805    here.  */
14806
14807 tree
14808 maybe_build_cleanup (decl)
14809      tree decl;
14810 {
14811   tree type = TREE_TYPE (decl);
14812
14813   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14814     {
14815       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14816       tree rval;
14817
14818       if (TREE_CODE (type) == ARRAY_TYPE)
14819         rval = decl;
14820       else
14821         {
14822           mark_addressable (decl);
14823           rval = build_unary_op (ADDR_EXPR, decl, 0);
14824         }
14825
14826       /* Optimize for space over speed here.  */
14827       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14828           || flag_expensive_optimizations)
14829         flags |= LOOKUP_NONVIRTUAL;
14830
14831       rval = build_delete (TREE_TYPE (rval), rval,
14832                            sfk_complete_destructor, flags, 0);
14833
14834       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14835           && ! TYPE_HAS_DESTRUCTOR (type))
14836         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14837                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14838
14839       return rval;
14840     }
14841   return 0;
14842 }
14843 \f
14844 /* Expand a C++ expression at the statement level.
14845    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14846    The C++ type checker should get all of these out when
14847    expressions are combined with other, type-providing, expressions,
14848    leaving only orphan expressions, such as:
14849
14850    &class::bar;         / / takes its address, but does nothing with it.  */
14851
14852 void
14853 cplus_expand_expr_stmt (exp)
14854      tree exp;
14855 {
14856 #if 0
14857   /* We should do this eventually, but right now this causes regex.o from
14858      libg++ to miscompile, and tString to core dump.  */
14859   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14860 #endif
14861
14862   /* If we don't do this, we end up down inside expand_expr
14863      trying to do TYPE_MODE on the ERROR_MARK, and really
14864      go outside the bounds of the type.  */
14865   if (exp != error_mark_node)
14866     expand_expr_stmt (exp);
14867 }
14868
14869 /* When a stmt has been parsed, this function is called.  */
14870
14871 void
14872 finish_stmt ()
14873 {
14874   /* Always assume this statement was not an expression statement.  If
14875      it actually was an expression statement, its our callers
14876      responsibility to fix this up.  */
14877   last_expr_type = NULL_TREE;
14878 }
14879
14880 /* DECL was originally constructed as a non-static member function,
14881    but turned out to be static.  Update it accordingly.  */
14882
14883 void
14884 revert_static_member_fn (decl)
14885      tree decl;
14886 {
14887   tree tmp;
14888   tree function = TREE_TYPE (decl);
14889   tree args = TYPE_ARG_TYPES (function);
14890
14891   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14892       != TYPE_UNQUALIFIED)
14893     cp_error ("static member function `%#D' declared with type qualifiers",
14894               *decl);
14895
14896   args = TREE_CHAIN (args);
14897   tmp = build_function_type (TREE_TYPE (function), args);
14898   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14899   tmp = build_exception_variant (tmp,
14900                                  TYPE_RAISES_EXCEPTIONS (function));
14901   TREE_TYPE (decl) = tmp;
14902   if (DECL_ARGUMENTS (decl))
14903     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14904   DECL_STATIC_FUNCTION_P (decl) = 1;
14905 }
14906
14907 /* Initialize the variables used during compilation of a C++
14908    function.  */
14909
14910 static void
14911 push_cp_function_context (f)
14912      struct function *f;
14913 {
14914   struct language_function *p
14915     = ((struct language_function *)
14916        xcalloc (1, sizeof (struct language_function)));
14917   f->language = p;
14918
14919   /* It takes an explicit call to expand_body to generate RTL for a
14920      function.  */
14921   expanding_p = 0;
14922
14923   /* Whenever we start a new function, we destroy temporaries in the
14924      usual way.  */
14925   current_stmt_tree->stmts_are_full_exprs_p = 1;
14926 }
14927
14928 /* Free the language-specific parts of F, now that we've finished
14929    compiling the function.  */
14930
14931 static void
14932 pop_cp_function_context (f)
14933      struct function *f;
14934 {
14935   if (f->language)
14936     free (f->language);
14937   f->language = 0;
14938 }
14939
14940 /* Mark P for GC.  */
14941
14942 static void
14943 mark_lang_function (p)
14944      struct language_function *p;
14945 {
14946   if (!p)
14947     return;
14948
14949   ggc_mark_tree (p->x_ctor_label);
14950   ggc_mark_tree (p->x_dtor_label);
14951   ggc_mark_tree (p->x_current_class_ptr);
14952   ggc_mark_tree (p->x_current_class_ref);
14953   ggc_mark_tree (p->x_eh_spec_try_block);
14954   ggc_mark_tree (p->x_scope_stmt_stack);
14955
14956   ggc_mark_rtx (p->x_result_rtx);
14957
14958   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14959   mark_stmt_tree (&p->x_stmt_tree);
14960   mark_binding_level (&p->bindings);
14961 }
14962
14963 /* Mark the language-specific data in F for GC.  */
14964
14965 static void
14966 mark_cp_function_context (f)
14967      struct function *f;
14968 {
14969   mark_lang_function (f->language);
14970 }
14971
14972 void
14973 lang_mark_false_label_stack (l)
14974      struct label_node *l;
14975 {
14976   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14977   my_friendly_assert (l == NULL, 19990904);
14978 }
14979
14980 void
14981 lang_mark_tree (t)
14982      tree t;
14983 {
14984   enum tree_code code = TREE_CODE (t);
14985   if (code == IDENTIFIER_NODE)
14986     {
14987       struct lang_identifier *li = (struct lang_identifier *) t;
14988       struct lang_id2 *li2 = li->x;
14989       ggc_mark_tree (li->namespace_bindings);
14990       ggc_mark_tree (li->bindings);
14991       ggc_mark_tree (li->class_value);
14992       ggc_mark_tree (li->class_template_info);
14993
14994       if (li2)
14995         {
14996           ggc_mark_tree (li2->label_value);
14997           ggc_mark_tree (li2->implicit_decl);
14998           ggc_mark_tree (li2->error_locus);
14999         }
15000     }
15001   else if (code == CPLUS_BINDING)
15002     {
15003       if (BINDING_HAS_LEVEL_P (t))
15004         mark_binding_level (&BINDING_LEVEL (t));
15005       else
15006         ggc_mark_tree (BINDING_SCOPE (t));
15007       ggc_mark_tree (BINDING_VALUE (t));
15008     }
15009   else if (code == OVERLOAD)
15010     ggc_mark_tree (OVL_FUNCTION (t));
15011   else if (code == TEMPLATE_PARM_INDEX)
15012     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
15013   else if (TREE_CODE_CLASS (code) == 'd')
15014     {
15015       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
15016
15017       if (ld)
15018         {
15019           ggc_mark (ld);
15020           if (!DECL_GLOBAL_CTOR_P (t)
15021               && !DECL_GLOBAL_DTOR_P (t)
15022               && !DECL_THUNK_P (t))
15023             ggc_mark_tree (ld->decl_flags.u2.access);
15024           else if (DECL_THUNK_P (t))
15025             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
15026           ggc_mark_tree (ld->decl_flags.context);
15027           if (TREE_CODE (t) != NAMESPACE_DECL)
15028             ggc_mark_tree (ld->decl_flags.u.template_info);
15029           else
15030             mark_binding_level (&NAMESPACE_LEVEL (t));
15031           if (CAN_HAVE_FULL_LANG_DECL_P (t))
15032             {
15033               ggc_mark_tree (ld->befriending_classes);
15034               ggc_mark_tree (ld->saved_tree);
15035               ggc_mark_tree (ld->cloned_function);
15036               if (!DECL_OVERLOADED_OPERATOR_P (t))
15037                 ggc_mark_tree (ld->u2.vtt_parm);
15038               if (TREE_CODE (t) == TYPE_DECL)
15039                 ggc_mark_tree (ld->u.sorted_fields);
15040               else if (TREE_CODE (t) == FUNCTION_DECL
15041                        && !DECL_PENDING_INLINE_P (t))
15042                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
15043             }
15044         }
15045     }
15046   else if (TREE_CODE_CLASS (code) == 't')
15047     {
15048       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
15049
15050       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15051                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15052         {
15053           ggc_mark (lt);
15054           ggc_mark_tree (lt->vfields);
15055           ggc_mark_tree (lt->vbases);
15056           ggc_mark_tree (lt->tags);
15057           ggc_mark_tree (lt->size);
15058           ggc_mark_tree (lt->pure_virtuals);
15059           ggc_mark_tree (lt->friend_classes);
15060           ggc_mark_tree (lt->rtti);
15061           ggc_mark_tree (lt->methods);
15062           ggc_mark_tree (lt->template_info);
15063           ggc_mark_tree (lt->befriending_classes);
15064         }
15065       else if (lt)
15066         /* In the case of pointer-to-member function types, the
15067            TYPE_LANG_SPECIFIC is really just a tree.  */
15068         ggc_mark_tree ((tree) lt);
15069     }
15070 }