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 "defaults.h"
  41 #include "output.h"
  42 #include "except.h"
  43 #include "toplev.h"
  44 #include "../hash.h"
  45 #include "defaults.h"
  46 #include "ggc.h"
  47
  48 extern int current_class_depth;
  49
  50 extern tree static_ctors, static_dtors;
  51
  52 extern tree global_namespace;
  53
  54 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  55
  56 /* Use garbage collection.  */
  57
  58 int ggc_p = 1;
  59
  60 #ifndef WCHAR_UNSIGNED
  61 #define WCHAR_UNSIGNED 0
  62 #endif
  63
  64 #ifndef CHAR_TYPE_SIZE
  65 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  66 #endif
  67
  68 #ifndef BOOL_TYPE_SIZE
  69 #ifdef SLOW_BYTE_ACCESS
  70 /* In the new ABI, `bool' has size and alignment `1', on all
  71    platforms.  */
  72 #define BOOL_TYPE_SIZE \
  73   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  74 #else
  75 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  76 #endif
  77 #endif
  78
  79 /* We let tm.h override the types used here, to handle trivial differences
  80    such as the choice of unsigned int or long unsigned int for size_t.
  81    When machines start needing nontrivial differences in the size type,
  82    it would be best to do something here to figure out automatically
  83    from other information what type to use.  */
  84
  85 #ifndef SIZE_TYPE
  86 #define SIZE_TYPE "long unsigned int"
  87 #endif
  88
  89 #ifndef PTRDIFF_TYPE
  90 #define PTRDIFF_TYPE "long int"
  91 #endif
  92
  93 #ifndef WCHAR_TYPE
  94 #define WCHAR_TYPE "int"
  95 #endif
  96
  97 static tree grokparms                           PARAMS ((tree, int));
  98 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  99
 100 static void push_binding_level PARAMS ((struct binding_level *, int,
 101                                       int));
 102 static void pop_binding_level PARAMS ((void));
 103 static void suspend_binding_level PARAMS ((void));
 104 static void resume_binding_level PARAMS ((struct binding_level *));
 105 static struct binding_level *make_binding_level PARAMS ((void));
 106 static void declare_namespace_level PARAMS ((void));
 107 static int decl_jump_unsafe PARAMS ((tree));
 108 static void storedecls PARAMS ((tree));
 109 static void require_complete_types_for_parms PARAMS ((tree));
 110 static int ambi_op_p PARAMS ((enum tree_code));
 111 static int unary_op_p PARAMS ((enum tree_code));
 112 static tree store_bindings PARAMS ((tree, tree));
 113 static tree lookup_tag_reverse PARAMS ((tree, tree));
 114 static tree obscure_complex_init PARAMS ((tree, tree));
 115 static tree lookup_name_real PARAMS ((tree, int, int, int));
 116 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 117 static void grok_reference_init PARAMS ((tree, tree, tree));
 118 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 119                               enum overload_flags, tree,
 120                               tree, int, int, int, int, int, int, tree));
 121 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 122 static tree lookup_tag PARAMS ((enum tree_code, tree,
 123                               struct binding_level *, int));
 124 static void set_identifier_type_value_with_scope
 125         PARAMS ((tree, tree, struct binding_level *));
 126 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 127 static void record_unknown_type PARAMS ((tree, const char *));
 128 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
 129 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 130 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 131                                   int));
 132 static void lang_print_error_function PARAMS ((const char *));
 133 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 134 static void check_for_uninitialized_const_var PARAMS ((tree));
 135 static unsigned long typename_hash PARAMS ((hash_table_key));
 136 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 137 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 138 static int add_binding PARAMS ((tree, tree));
 139 static void pop_binding PARAMS ((tree, tree));
 140 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 141 static tree find_binding PARAMS ((tree, tree));
 142 static tree select_decl PARAMS ((tree, int));
 143 static int lookup_flags PARAMS ((int, int));
 144 static tree qualify_lookup PARAMS ((tree, int));
 145 static tree record_builtin_java_type PARAMS ((const char *, int));
 146 static const char *tag_name PARAMS ((enum tag_types code));
 147 static void find_class_binding_level PARAMS ((void));
 148 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 149 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 150 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 151 static int walk_globals_r PARAMS ((tree, void *));
 152 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 153 static tree make_label_decl PARAMS ((tree, int));
 154 static void use_label PARAMS ((tree));
 155 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 156                                            const char *, int));
 157 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 158 static void check_switch_goto PARAMS ((struct binding_level *));
 159 static void check_previous_gotos PARAMS ((tree));
 160 static void pop_label PARAMS ((tree, tree));
 161 static void pop_labels PARAMS ((tree));
 162 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 163 static void layout_var_decl PARAMS ((tree));
 164 static void maybe_commonize_var PARAMS ((tree));
 165 static tree check_initializer PARAMS ((tree, tree));
 166 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 167 static void push_cp_function_context PARAMS ((struct function *));
 168 static void pop_cp_function_context PARAMS ((struct function *));
 169 static void mark_binding_level PARAMS ((void *));
 170 static void mark_named_label_lists PARAMS ((void *, void *));
 171 static void mark_cp_function_context PARAMS ((struct function *));
 172 static void mark_saved_scope PARAMS ((void *));
 173 static void mark_lang_function PARAMS ((struct language_function *));
 174 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 175 static void save_function_data PARAMS ((tree));
 176 static void check_function_type PARAMS ((tree));
 177 static void destroy_local_var PARAMS ((tree));
 178 static void finish_constructor_body PARAMS ((void));
 179 static void finish_destructor_body PARAMS ((void));
 180 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 181 static tree get_atexit_node PARAMS ((void));
 182 static tree get_dso_handle_node PARAMS ((void));
 183 static tree start_cleanup_fn PARAMS ((void));
 184 static void end_cleanup_fn PARAMS ((void));
 185 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 186 static void initialize_predefined_identifiers PARAMS ((void));
 187 static tree check_special_function_return_type
 188   PARAMS ((special_function_kind, tree, tree, tree));
 189 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 190 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 191
 192 #if defined (DEBUG_CP_BINDING_LEVELS)
 193 static void indent PARAMS ((void));
 194 #endif
 195
 196 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 197 tree error_mark_list;
 198
 199 /* The following symbols are subsumed in the cp_global_trees array, and
 200    listed here individually for documentation purposes.
 201
 202    C++ extensions
 203         tree wchar_decl_node;
 204         tree void_zero_node;
 205
 206         tree vtable_entry_type;
 207         tree delta_type_node;
 208 #if 0
 209    Old rtti stuff.
 210         tree __baselist_desc_type_node;
 211         tree __i_desc_type_node, __m_desc_type_node;
 212         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 213 #endif
 214         tree __t_desc_type_node;
 215 #if 0
 216         tree __tp_desc_type_node;
 217 #endif
 218         tree ti_desc_type_node;
 219         tree bltn_desc_type_node, ptr_desc_type_node;
 220         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 221         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 222         tree ptm_desc_type_node;
 223         tree base_desc_type_node;
 224 #if 0
 225    Not needed yet?  May be needed one day?
 226         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 227         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 228         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 229 #endif
 230
 231         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 232         tree unknown_type_node;
 233
 234    Array type `vtable_entry_type[]'
 235
 236         tree vtbl_type_node;
 237         tree vtbl_ptr_type_node;
 238
 239    Namespaces,
 240
 241         tree std_node;
 242         tree abi_node;
 243
 244    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 245    one that the user will declare, but sufficient to be called
 246    by routines that want to abort the program.
 247
 248         tree abort_fndecl;
 249
 250    The FUNCTION_DECL for the default `::operator delete'.
 251
 252         tree global_delete_fndecl;
 253
 254    Used by RTTI
 255         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 256         tree tinfo_var_id;
 257
 258 */
 259
 260 tree cp_global_trees[CPTI_MAX];
 261
 262 /* Indicates that there is a type value in some namespace, although
 263    that is not necessarily in scope at the moment.  */
 264
 265 static tree global_type_node;
 266
 267 /* Namespace std.  */
 268 int in_std;
 269
 270 /* Expect only namespace names now. */
 271 static int only_namespace_names;
 272
 273 /* If original DECL_RESULT of current function was a register,
 274    but due to being an addressable named return value, would up
 275    on the stack, this variable holds the named return value's
 276    original location.  */
 277
 278 #define original_result_rtx cp_function_chain->x_result_rtx
 279
 280 /* Used only for jumps to as-yet undefined labels, since jumps to
 281    defined labels can have their validity checked immediately.  */
 282
 283 struct named_label_use_list
 284 {
 285   struct binding_level *binding_level;
 286   tree names_in_scope;
 287   tree label_decl;
 288   const char *filename_o_goto;
 289   int lineno_o_goto;
 290   struct named_label_use_list *next;
 291 };
 292
 293 #define named_label_uses cp_function_chain->x_named_label_uses
 294
 295 /* A list of objects which have constructors or destructors
 296    which reside in the global scope.  The decl is stored in
 297    the TREE_VALUE slot and the initializer is stored
 298    in the TREE_PURPOSE slot.  */
 299 tree static_aggregates;
 300
 301 /* -- end of C++ */
 302
 303 /* A node for the integer constants 2, and 3.  */
 304
 305 tree integer_two_node, integer_three_node;
 306
 307 /* Parsing a function declarator leaves here a chain of structure
 308    and enum types declared in the parmlist.  */
 309
 310 static tree last_function_parm_tags;
 311
 312 /* Similar, for last_function_parm_tags.  */
 313 tree last_function_parms;
 314 static tree current_function_parm_tags;
 315
 316 /* A list of all LABEL_DECLs in the function that have names.  Here so
 317    we can clear out their names' definitions at the end of the
 318    function, and so we can check the validity of jumps to these labels.  */
 319
 320 struct named_label_list
 321 {
 322   struct binding_level *binding_level;
 323   tree names_in_scope;
 324   tree old_value;
 325   tree label_decl;
 326   tree bad_decls;
 327   int eh_region;
 328   struct named_label_list *next;
 329 };
 330
 331 #define named_labels cp_function_chain->x_named_labels
 332
 333 /* Set to 0 at beginning of a function definition, and whenever
 334    a label (case or named) is defined.  Set to value of expression
 335    returned from function when that value can be transformed into
 336    a named return value.  */
 337
 338 tree current_function_return_value;
 339
 340 /* Nonzero means use the ISO C99 dialect of C.  */
 341
 342 int flag_isoc99;
 343
 344 /* Nonzero means give `double' the same size as `float'.  */
 345
 346 extern int flag_short_double;
 347
 348 /* Nonzero means don't recognize any builtin functions.  */
 349
 350 extern int flag_no_builtin;
 351
 352 /* Nonzero means don't recognize the non-ANSI builtin functions.
 353    -ansi sets this.  */
 354
 355 extern int flag_no_nonansi_builtin;
 356
 357 /* Nonzero if we want to conserve space in the .o files.  We do this
 358    by putting uninitialized data and runtime initialized data into
 359    .common instead of .data at the expense of not flagging multiple
 360    definitions.  */
 361 extern int flag_conserve_space;
 362 \f
 363 /* C and C++ flags are in decl2.c.  */
 364
 365 /* Flag used when debugging spew.c */
 366
 367 extern int spew_debug;
 368
 369 /* A expression of value 0 with the same precision as a sizetype
 370    node, but signed.  */
 371 tree signed_size_zero_node;
 372
 373 /* The name of the anonymous namespace, throughout this translation
 374    unit.  */
 375 tree anonymous_namespace_name;
 376
 377 /* The number of function bodies which we are currently processing.
 378    (Zero if we are at namespace scope, one inside the body of a
 379    function, two inside the body of a function in a local class, etc.)  */
 380 int function_depth;
 381 \f
 382 /* For each binding contour we allocate a binding_level structure
 383    which records the names defined in that contour.
 384    Contours include:
 385     0) the global one
 386     1) one for each function definition,
 387        where internal declarations of the parameters appear.
 388     2) one for each compound statement,
 389        to record its declarations.
 390
 391    The current meaning of a name can be found by searching the levels
 392    from the current one out to the global one.
 393
 394    Off to the side, may be the class_binding_level.  This exists only
 395    to catch class-local declarations.  It is otherwise nonexistent.
 396
 397    Also there may be binding levels that catch cleanups that must be
 398    run when exceptions occur.  Thus, to see whether a name is bound in
 399    the current scope, it is not enough to look in the
 400    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 401    instead.  */
 402
 403 /* Note that the information in the `names' component of the global contour
 404    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 405
 406 struct binding_level
 407   {
 408     /* A chain of _DECL nodes for all variables, constants, functions,
 409        and typedef types.  These are in the reverse of the order
 410        supplied.  There may be OVERLOADs on this list, too, but they
 411        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 412     tree names;
 413
 414     /* A list of structure, union and enum definitions, for looking up
 415        tag names.
 416        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 417        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 418        or ENUMERAL_TYPE node.
 419
 420        C++: the TREE_VALUE nodes can be simple types for
 421        component_bindings.  */
 422     tree tags;
 423
 424     /* A list of USING_DECL nodes. */
 425     tree usings;
 426
 427     /* A list of used namespaces. PURPOSE is the namespace,
 428        VALUE the common ancestor with this binding_level's namespace. */
 429     tree using_directives;
 430
 431     /* If this binding level is the binding level for a class, then
 432        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 433        is the name of an entity bound in the class; the TREE_VALUE is
 434        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 435        when leaving class scope, we can restore the
 436        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 437        the DECL bound by this name in the class.  */
 438     tree class_shadowed;
 439
 440     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 441        is used for all binding levels.  */
 442     tree type_shadowed;
 443
 444     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 445        label in this scope.  The TREE_PURPOSE is the previous value of
 446        the IDENTIFIER_LABEL VALUE.  */
 447     tree shadowed_labels;
 448
 449     /* For each level (except not the global one),
 450        a chain of BLOCK nodes for all the levels
 451        that were entered and exited one level down.  */
 452     tree blocks;
 453
 454     /* The BLOCK node for this level, if one has been preallocated.
 455        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 456     tree this_block;
 457
 458     /* The _TYPE node for this level, if parm_flag == 2.  */
 459     tree this_class;
 460
 461     /* The binding level which this one is contained in (inherits from).  */
 462     struct binding_level *level_chain;
 463
 464     /* List of decls in `names' that have incomplete
 465        structure or union types.  */
 466     tree incomplete;
 467
 468     /* List of VAR_DECLS saved from a previous for statement.
 469        These would be dead in ISO-conforming code, but might
 470        be referenced in ARM-era code.  These are stored in a
 471        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 472     tree dead_vars_from_for;
 473
 474     /* 1 for the level that holds the parameters of a function.
 475        2 for the level that holds a class declaration.  */
 476     unsigned parm_flag : 2;
 477
 478     /* 1 means make a BLOCK for this level regardless of all else.
 479        2 for temporary binding contours created by the compiler.  */
 480     unsigned keep : 2;
 481
 482     /* Nonzero if this level "doesn't exist" for tags.  */
 483     unsigned tag_transparent : 1;
 484
 485     /* Nonzero if this level can safely have additional
 486        cleanup-needing variables added to it.  */
 487     unsigned more_cleanups_ok : 1;
 488     unsigned have_cleanups : 1;
 489
 490     /* Nonzero if this scope is for storing the decls for template
 491        parameters and generic decls; these decls will be discarded and
 492        replaced with a TEMPLATE_DECL.  */
 493     unsigned template_parms_p : 1;
 494
 495     /* Nonzero if this scope corresponds to the `<>' in a
 496        `template <>' clause.  Whenever this flag is set,
 497        TEMPLATE_PARMS_P will be set as well.  */
 498     unsigned template_spec_p : 1;
 499
 500     /* This is set for a namespace binding level.  */
 501     unsigned namespace_p : 1;
 502
 503     /* True if this level is that of a for-statement where we need to
 504        worry about ambiguous (ARM or ISO) scope rules.  */
 505     unsigned is_for_scope : 1;
 506
 507     /* True if this level corresponds to an EH region, as for a try block.
 508        Currently this information is only available while building the
 509        tree structure.  */
 510     unsigned eh_region : 1;
 511
 512     /* Four bits left for this word.  */
 513
 514 #if defined(DEBUG_CP_BINDING_LEVELS)
 515     /* Binding depth at which this level began.  */
 516     unsigned binding_depth;
 517 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 518   };
 519
 520 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 521
 522 /* The binding level currently in effect.  */
 523
 524 #define current_binding_level                   \
 525   (cfun                                         \
 526    ? cp_function_chain->bindings                \
 527    : scope_chain->bindings)
 528
 529 /* The binding level of the current class, if any.  */
 530
 531 #define class_binding_level scope_chain->class_bindings
 532
 533 /* A chain of binding_level structures awaiting reuse.  */
 534
 535 static struct binding_level *free_binding_level;
 536
 537 /* The outermost binding level, for names of file scope.
 538    This is created when the compiler is started and exists
 539    through the entire run.  */
 540
 541 static struct binding_level *global_binding_level;
 542
 543 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 544
 545 static int keep_next_level_flag;
 546
 547 #if defined(DEBUG_CP_BINDING_LEVELS)
 548 static int binding_depth = 0;
 549 static int is_class_level = 0;
 550
 551 static void
 552 indent ()
 553 {
 554   register unsigned i;
 555
 556   for (i = 0; i < binding_depth*2; i++)
 557     putc (' ', stderr);
 558 }
 559 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 560
 561 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 562
 563 static void
 564 push_binding_level (newlevel, tag_transparent, keep)
 565      struct binding_level *newlevel;
 566      int tag_transparent, keep;
 567 {
 568   /* Add this level to the front of the chain (stack) of levels that
 569      are active.  */
 570   bzero ((char*) newlevel, sizeof (struct binding_level));
 571   newlevel->level_chain = current_binding_level;
 572   current_binding_level = newlevel;
 573   newlevel->tag_transparent = tag_transparent;
 574   newlevel->more_cleanups_ok = 1;
 575
 576   newlevel->keep = keep;
 577 #if defined(DEBUG_CP_BINDING_LEVELS)
 578   newlevel->binding_depth = binding_depth;
 579   indent ();
 580   fprintf (stderr, "push %s level 0x%08x line %d\n",
 581            (is_class_level) ? "class" : "block", newlevel, lineno);
 582   is_class_level = 0;
 583   binding_depth++;
 584 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 585 }
 586
 587 /* Find the innermost enclosing class scope, and reset
 588    CLASS_BINDING_LEVEL appropriately.  */
 589
 590 static void
 591 find_class_binding_level ()
 592 {
 593   struct binding_level *level = current_binding_level;
 594
 595   while (level && level->parm_flag != 2)
 596     level = level->level_chain;
 597   if (level && level->parm_flag == 2)
 598     class_binding_level = level;
 599   else
 600     class_binding_level = 0;
 601 }
 602
 603 static void
 604 pop_binding_level ()
 605 {
 606   if (global_binding_level)
 607     {
 608       /* Cannot pop a level, if there are none left to pop.  */
 609       if (current_binding_level == global_binding_level)
 610         my_friendly_abort (123);
 611     }
 612   /* Pop the current level, and free the structure for reuse.  */
 613 #if defined(DEBUG_CP_BINDING_LEVELS)
 614   binding_depth--;
 615   indent ();
 616   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 617           (is_class_level) ? "class" : "block",
 618           current_binding_level, lineno);
 619   if (is_class_level != (current_binding_level == class_binding_level))
 620     {
 621       indent ();
 622       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 623     }
 624   is_class_level = 0;
 625 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 626   {
 627     register struct binding_level *level = current_binding_level;
 628     current_binding_level = current_binding_level->level_chain;
 629     level->level_chain = free_binding_level;
 630 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 631     if (level->binding_depth != binding_depth)
 632       abort ();
 633 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 634     free_binding_level = level;
 635     find_class_binding_level ();
 636   }
 637 }
 638
 639 static void
 640 suspend_binding_level ()
 641 {
 642   if (class_binding_level)
 643     current_binding_level = class_binding_level;
 644
 645   if (global_binding_level)
 646     {
 647       /* Cannot suspend a level, if there are none left to suspend.  */
 648       if (current_binding_level == global_binding_level)
 649         my_friendly_abort (123);
 650     }
 651   /* Suspend the current level.  */
 652 #if defined(DEBUG_CP_BINDING_LEVELS)
 653   binding_depth--;
 654   indent ();
 655   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 656           (is_class_level) ? "class" : "block",
 657           current_binding_level, lineno);
 658   if (is_class_level != (current_binding_level == class_binding_level))
 659     {
 660       indent ();
 661       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 662     }
 663   is_class_level = 0;
 664 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 665   current_binding_level = current_binding_level->level_chain;
 666   find_class_binding_level ();
 667 }
 668
 669 static void
 670 resume_binding_level (b)
 671      struct binding_level *b;
 672 {
 673   /* Resuming binding levels is meant only for namespaces,
 674      and those cannot nest into classes. */
 675   my_friendly_assert(!class_binding_level, 386);
 676   /* Also, resuming a non-directly nested namespace is a no-no.  */
 677   my_friendly_assert(b->level_chain == current_binding_level, 386);
 678   current_binding_level = b;
 679 #if defined(DEBUG_CP_BINDING_LEVELS)
 680   b->binding_depth = binding_depth;
 681   indent ();
 682   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 683            (is_class_level) ? "class" : "block", b, lineno);
 684   is_class_level = 0;
 685   binding_depth++;
 686 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 687 }
 688 \f
 689 /* Create a new `struct binding_level'.  */
 690
 691 static
 692 struct binding_level *
 693 make_binding_level ()
 694 {
 695   /* NOSTRICT */
 696   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 697 }
 698
 699 /* Nonzero if we are currently in the global binding level.  */
 700
 701 int
 702 global_bindings_p ()
 703 {
 704   return current_binding_level == global_binding_level;
 705 }
 706
 707 /* Return the innermost binding level that is not for a class scope.  */
 708
 709 static struct binding_level *
 710 innermost_nonclass_level ()
 711 {
 712   struct binding_level *b;
 713
 714   b = current_binding_level;
 715   while (b->parm_flag == 2)
 716     b = b->level_chain;
 717
 718   return b;
 719 }
 720
 721 /* Nonzero if we are currently in a toplevel binding level.  This
 722    means either the global binding level or a namespace in a toplevel
 723    binding level.  Since there are no non-toplevel namespace levels,
 724    this really means any namespace or template parameter level.  We
 725    also include a class whose context is toplevel.  */
 726
 727 int
 728 toplevel_bindings_p ()
 729 {
 730   struct binding_level *b = innermost_nonclass_level ();
 731
 732   return b->namespace_p || b->template_parms_p;
 733 }
 734
 735 /* Nonzero if this is a namespace scope, or if we are defining a class
 736    which is itself at namespace scope, or whose enclosing class is
 737    such a class, etc.  */
 738
 739 int
 740 namespace_bindings_p ()
 741 {
 742   struct binding_level *b = innermost_nonclass_level ();
 743
 744   return b->namespace_p;
 745 }
 746
 747 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 748    unconditionally.  Otherwise, use the normal logic to decide whether
 749    or not to create a BLOCK.  */
 750
 751 void
 752 keep_next_level (keep)
 753      int keep;
 754 {
 755   keep_next_level_flag = keep;
 756 }
 757
 758 /* Nonzero if the current level needs to have a BLOCK made.  */
 759
 760 int
 761 kept_level_p ()
 762 {
 763   return (current_binding_level->blocks != NULL_TREE
 764           || current_binding_level->keep
 765           || current_binding_level->names != NULL_TREE
 766           || (current_binding_level->tags != NULL_TREE
 767               && !current_binding_level->tag_transparent));
 768 }
 769
 770 static void
 771 declare_namespace_level ()
 772 {
 773   current_binding_level->namespace_p = 1;
 774 }
 775
 776 /* Returns non-zero if this scope was created to store template
 777    parameters.  */
 778
 779 int
 780 template_parm_scope_p ()
 781 {
 782   return current_binding_level->template_parms_p;
 783 }
 784
 785 /* Returns the kind of template specialization we are currently
 786    processing, given that it's declaration contained N_CLASS_SCOPES
 787    explicit scope qualifications.  */
 788
 789 tmpl_spec_kind
 790 current_tmpl_spec_kind (n_class_scopes)
 791      int n_class_scopes;
 792 {
 793   int n_template_parm_scopes = 0;
 794   int seen_specialization_p = 0;
 795   int innermost_specialization_p = 0;
 796   struct binding_level *b;
 797
 798   /* Scan through the template parameter scopes.  */
 799   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 800     {
 801       /* If we see a specialization scope inside a parameter scope,
 802          then something is wrong.  That corresponds to a declaration
 803          like:
 804
 805             template <class T> template <> ...
 806
 807          which is always illegal since [temp.expl.spec] forbids the
 808          specialization of a class member template if the enclosing
 809          class templates are not explicitly specialized as well.  */
 810       if (b->template_spec_p)
 811         {
 812           if (n_template_parm_scopes == 0)
 813             innermost_specialization_p = 1;
 814           else
 815             seen_specialization_p = 1;
 816         }
 817       else if (seen_specialization_p == 1)
 818         return tsk_invalid_member_spec;
 819
 820       ++n_template_parm_scopes;
 821     }
 822
 823   /* Handle explicit instantiations.  */
 824   if (processing_explicit_instantiation)
 825     {
 826       if (n_template_parm_scopes != 0)
 827         /* We've seen a template parameter list during an explicit
 828            instantiation.  For example:
 829
 830              template <class T> template void f(int);
 831
 832            This is erroneous.  */
 833         return tsk_invalid_expl_inst;
 834       else
 835         return tsk_expl_inst;
 836     }
 837
 838   if (n_template_parm_scopes < n_class_scopes)
 839     /* We've not seen enough template headers to match all the
 840        specialized classes present.  For example:
 841
 842          template <class T> void R<T>::S<T>::f(int);
 843
 844        This is illegal; there needs to be one set of template
 845        parameters for each class.  */
 846     return tsk_insufficient_parms;
 847   else if (n_template_parm_scopes == n_class_scopes)
 848     /* We're processing a non-template declaration (even though it may
 849        be a member of a template class.)  For example:
 850
 851          template <class T> void S<T>::f(int);
 852
 853        The `class T' maches the `S<T>', leaving no template headers
 854        corresponding to the `f'.  */
 855     return tsk_none;
 856   else if (n_template_parm_scopes > n_class_scopes + 1)
 857     /* We've got too many template headers.  For example:
 858
 859          template <> template <class T> void f (T);
 860
 861        There need to be more enclosing classes.  */
 862     return tsk_excessive_parms;
 863   else
 864     /* This must be a template.  It's of the form:
 865
 866          template <class T> template <class U> void S<T>::f(U);
 867
 868        This is a specialization if the innermost level was a
 869        specialization; otherwise it's just a definition of the
 870        template.  */
 871     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 872 }
 873
 874 void
 875 set_class_shadows (shadows)
 876      tree shadows;
 877 {
 878   class_binding_level->class_shadowed = shadows;
 879 }
 880
 881 /* Enter a new binding level.
 882    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 883    not for that of tags.  */
 884
 885 void
 886 pushlevel (tag_transparent)
 887      int tag_transparent;
 888 {
 889   struct binding_level *newlevel;
 890
 891   if (cfun && !doing_semantic_analysis_p ())
 892     return;
 893
 894   /* Reuse or create a struct for this binding level.  */
 895 #if defined(DEBUG_CP_BINDING_LEVELS)
 896   if (0)
 897 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 898   if (free_binding_level)
 899 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 900     {
 901       newlevel = free_binding_level;
 902       free_binding_level = free_binding_level->level_chain;
 903     }
 904   else
 905     newlevel = make_binding_level ();
 906
 907   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 908   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 909   keep_next_level_flag = 0;
 910 }
 911
 912 /* Enter a new scope.  The KIND indicates what kind of scope is being
 913    created.  */
 914
 915 void
 916 begin_scope (sk)
 917      scope_kind sk;
 918 {
 919   pushlevel (0);
 920
 921   switch (sk)
 922     {
 923     case sk_template_spec:
 924       current_binding_level->template_spec_p = 1;
 925       /* Fall through.  */
 926
 927     case sk_template_parms:
 928       current_binding_level->template_parms_p = 1;
 929       break;
 930
 931     default:
 932       my_friendly_abort (20000309);
 933     }
 934 }
 935
 936 /* Exit the current scope.  */
 937
 938 void
 939 finish_scope ()
 940 {
 941   poplevel (0, 0, 0);
 942 }
 943
 944 void
 945 note_level_for_for ()
 946 {
 947   current_binding_level->is_for_scope = 1;
 948 }
 949
 950 /* Record that the current binding level represents a try block.  */
 951
 952 void
 953 note_level_for_eh ()
 954 {
 955   current_binding_level->eh_region = 1;
 956 }
 957
 958 /* For a binding between a name and an entity at a block scope,
 959    this is the `struct binding_level' for the block.  */
 960 #define BINDING_LEVEL(NODE) \
 961    (((struct tree_binding*)NODE)->scope.level)
 962
 963 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 964    level at which this declaration is being bound.  */
 965
 966 static void
 967 push_binding (id, decl, level)
 968      tree id;
 969      tree decl;
 970      struct binding_level* level;
 971 {
 972   tree binding;
 973
 974   binding = make_node (CPLUS_BINDING);
 975
 976   /* Now, fill in the binding information.  */
 977   BINDING_VALUE (binding) = decl;
 978   BINDING_TYPE (binding) = NULL_TREE;
 979   BINDING_LEVEL (binding) = level;
 980   INHERITED_VALUE_BINDING_P (binding) = 0;
 981   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 982   BINDING_HAS_LEVEL_P (binding) = 1;
 983
 984   /* And put it on the front of the list of bindings for ID.  */
 985   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 986   IDENTIFIER_BINDING (id) = binding;
 987 }
 988
 989 /* ID is already bound in the current scope.  But, DECL is an
 990    additional binding for ID in the same scope.  This is the `struct
 991    stat' hack whereby a non-typedef class-name or enum-name can be
 992    bound at the same level as some other kind of entity.  It's the
 993    responsibility of the caller to check that inserting this name is
 994    legal here.  Returns nonzero if the new binding was successful.  */
 995 static int
 996 add_binding (id, decl)
 997      tree id;
 998      tree decl;
 999 {
1000   tree binding = IDENTIFIER_BINDING (id);
1001   int ok = 1;
1002
1003   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1004     /* The new name is the type name.  */
1005     BINDING_TYPE (binding) = decl;
1006   else if (!BINDING_VALUE (binding))
1007     /* This situation arises when push_class_level_binding moves an
1008        inherited type-binding out of the way to make room for a new
1009        value binding.  */
1010     BINDING_VALUE (binding) = decl;
1011   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1012            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1013     {
1014       /* The old binding was a type name.  It was placed in
1015          BINDING_VALUE because it was thought, at the point it was
1016          declared, to be the only entity with such a name.  Move the
1017          type name into the type slot; it is now hidden by the new
1018          binding.  */
1019       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1020       BINDING_VALUE (binding) = decl;
1021       INHERITED_VALUE_BINDING_P (binding) = 0;
1022     }
1023   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1024            && TREE_CODE (decl) == TYPE_DECL
1025            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1026            && same_type_p (TREE_TYPE (decl),
1027                            TREE_TYPE (BINDING_VALUE (binding))))
1028     /* We have two typedef-names, both naming the same type to have
1029        the same name.  This is OK because of:
1030
1031          [dcl.typedef]
1032
1033          In a given scope, a typedef specifier can be used to redefine
1034          the name of any type declared in that scope to refer to the
1035          type to which it already refers.  */
1036     ok = 0;
1037   /* There can be two block-scope declarations of the same variable,
1038      so long as they are `extern' declarations.  */
1039   else if (TREE_CODE (decl) == VAR_DECL
1040            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1041            && DECL_EXTERNAL (decl)
1042            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1043     {
1044       duplicate_decls (decl, BINDING_VALUE (binding));
1045       ok = 0;
1046     }
1047   else
1048     {
1049       cp_error ("declaration of `%#D'", decl);
1050       cp_error_at ("conflicts with previous declaration `%#D'",
1051                    BINDING_VALUE (binding));
1052       ok = 0;
1053     }
1054
1055   return ok;
1056 }
1057
1058 /* Add DECL to the list of things declared in B.  */
1059
1060 static void
1061 add_decl_to_level (decl, b)
1062      tree decl;
1063      struct binding_level *b;
1064 {
1065   /* We build up the list in reverse order, and reverse it later if
1066      necessary.  */
1067   TREE_CHAIN (decl) = b->names;
1068   b->names = decl;
1069 }
1070
1071 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1072    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1073    doesn't really belong to this binding level, that it got here
1074    through a using-declaration.  */
1075
1076 void
1077 push_local_binding (id, decl, flags)
1078      tree id;
1079      tree decl;
1080      int flags;
1081 {
1082   struct binding_level *b;
1083
1084   /* Skip over any local classes.  This makes sense if we call
1085      push_local_binding with a friend decl of a local class.  */
1086   b = current_binding_level;
1087   while (b->parm_flag == 2)
1088     b = b->level_chain;
1089
1090   if (lookup_name_current_level (id))
1091     {
1092       /* Supplement the existing binding.  */
1093       if (!add_binding (id, decl))
1094         /* It didn't work.  Something else must be bound at this
1095            level.  Do not add DECL to the list of things to pop
1096            later.  */
1097         return;
1098     }
1099   else
1100     /* Create a new binding.  */
1101     push_binding (id, decl, b);
1102
1103   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1104     /* We must put the OVERLOAD into a TREE_LIST since the
1105        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1106        decls that got here through a using-declaration.  */
1107     decl = build_tree_list (NULL_TREE, decl);
1108
1109   /* And put DECL on the list of things declared by the current
1110      binding level.  */
1111   add_decl_to_level (decl, b);
1112 }
1113
1114 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1115    binding was successful.  */
1116
1117 int
1118 push_class_binding (id, decl)
1119      tree id;
1120      tree decl;
1121 {
1122   int result = 1;
1123   tree binding = IDENTIFIER_BINDING (id);
1124   tree context;
1125
1126   /* Note that we declared this value so that we can issue an error if
1127      this an illegal redeclaration of a name already used for some
1128      other purpose.  */
1129   note_name_declared_in_class (id, decl);
1130
1131   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1132     /* Supplement the existing binding.  */
1133     result = add_binding (id, decl);
1134   else
1135     /* Create a new binding.  */
1136     push_binding (id, decl, class_binding_level);
1137
1138   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1139      class-level declaration.  Note that we do not use DECL here
1140      because of the possibility of the `struct stat' hack; if DECL is
1141      a class-name or enum-name we might prefer a field-name, or some
1142      such.  */
1143   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1144
1145   /* If this is a binding from a base class, mark it as such.  */
1146   binding = IDENTIFIER_BINDING (id);
1147   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1148     {
1149       /* Any implicit typename must be from a base-class.  The
1150          context for an implicit typename declaration is always
1151          the derived class in which the lookup was done, so the checks
1152          based on the context of DECL below will not trigger.  */
1153       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1154         INHERITED_VALUE_BINDING_P (binding) = 1;
1155       else
1156         {
1157           if (TREE_CODE (decl) == OVERLOAD)
1158             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1159           else
1160             {
1161               my_friendly_assert (DECL_P (decl), 0);
1162               context = CP_DECL_CONTEXT (decl);
1163             }
1164
1165           if (is_properly_derived_from (current_class_type, context))
1166             INHERITED_VALUE_BINDING_P (binding) = 1;
1167           else
1168             INHERITED_VALUE_BINDING_P (binding) = 0;
1169         }
1170     }
1171   else if (BINDING_VALUE (binding) == decl)
1172     /* We only encounter a TREE_LIST when push_class_decls detects an
1173        ambiguity.  Such an ambiguity can be overridden by a definition
1174        in this class.  */
1175     INHERITED_VALUE_BINDING_P (binding) = 1;
1176
1177   return result;
1178 }
1179
1180 /* Remove the binding for DECL which should be the innermost binding
1181    for ID.  */
1182
1183 static void
1184 pop_binding (id, decl)
1185      tree id;
1186      tree decl;
1187 {
1188   tree binding;
1189
1190   if (id == NULL_TREE)
1191     /* It's easiest to write the loops that call this function without
1192        checking whether or not the entities involved have names.  We
1193        get here for such an entity.  */
1194     return;
1195
1196   /* Get the innermost binding for ID.  */
1197   binding = IDENTIFIER_BINDING (id);
1198
1199   /* The name should be bound.  */
1200   my_friendly_assert (binding != NULL_TREE, 0);
1201
1202   /* The DECL will be either the ordinary binding or the type
1203      binding for this identifier.  Remove that binding.  */
1204   if (BINDING_VALUE (binding) == decl)
1205     BINDING_VALUE (binding) = NULL_TREE;
1206   else if (BINDING_TYPE (binding) == decl)
1207     BINDING_TYPE (binding) = NULL_TREE;
1208   else
1209     my_friendly_abort (0);
1210
1211   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1212     /* We're completely done with the innermost binding for this
1213        identifier.  Unhook it from the list of bindings.  */
1214     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1215 }
1216
1217 /* When a label goes out of scope, check to see if that label was used
1218    in a valid manner, and issue any appropriate warnings or errors.  */
1219
1220 static void
1221 pop_label (label, old_value)
1222      tree label;
1223      tree old_value;
1224 {
1225   if (!processing_template_decl && doing_semantic_analysis_p ())
1226     {
1227       if (DECL_INITIAL (label) == NULL_TREE)
1228         {
1229           cp_error_at ("label `%D' used but not defined", label);
1230           /* Avoid crashing later.  */
1231           define_label (input_filename, 1, DECL_NAME (label));
1232         }
1233       else if (warn_unused_label && !TREE_USED (label))
1234         cp_warning_at ("label `%D' defined but not used", label);
1235     }
1236
1237   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1238 }
1239
1240 /* At the end of a function, all labels declared within the fucntion
1241    go out of scope.  BLOCK is the top-level block for the
1242    function.  */
1243
1244 static void
1245 pop_labels (block)
1246      tree block;
1247 {
1248   struct named_label_list *link;
1249
1250   /* Clear out the definitions of all label names, since their scopes
1251      end here.  */
1252   for (link = named_labels; link; link = link->next)
1253     {
1254       pop_label (link->label_decl, link->old_value);
1255       /* Put the labels into the "variables" of the top-level block,
1256          so debugger can see them.  */
1257       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1258       BLOCK_VARS (block) = link->label_decl;
1259     }
1260
1261   named_labels = NULL;
1262 }
1263
1264 /* Exit a binding level.
1265    Pop the level off, and restore the state of the identifier-decl mappings
1266    that were in effect when this level was entered.
1267
1268    If KEEP == 1, this level had explicit declarations, so
1269    and create a "block" (a BLOCK node) for the level
1270    to record its declarations and subblocks for symbol table output.
1271
1272    If FUNCTIONBODY is nonzero, this level is the body of a function,
1273    so create a block as if KEEP were set and also clear out all
1274    label names.
1275
1276    If REVERSE is nonzero, reverse the order of decls before putting
1277    them into the BLOCK.  */
1278
1279 tree
1280 poplevel (keep, reverse, functionbody)
1281      int keep;
1282      int reverse;
1283      int functionbody;
1284 {
1285   register tree link;
1286   /* The chain of decls was accumulated in reverse order.
1287      Put it into forward order, just for cleanliness.  */
1288   tree decls;
1289   int tmp = functionbody;
1290   int real_functionbody;
1291   tree tags;
1292   tree subblocks;
1293   tree block = NULL_TREE;
1294   tree decl;
1295   int block_previously_created;
1296   int leaving_for_scope;
1297
1298   if (cfun && !doing_semantic_analysis_p ())
1299     return NULL_TREE;
1300
1301   my_friendly_assert (current_binding_level->parm_flag != 2,
1302                       19990916);
1303
1304   real_functionbody = (current_binding_level->keep == 2
1305                        ? ((functionbody = 0), tmp) : functionbody);
1306   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1307   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1308
1309   my_friendly_assert (!current_binding_level->class_shadowed,
1310                       19990414);
1311
1312   /* We used to use KEEP == 2 to indicate that the new block should go
1313      at the beginning of the list of blocks at this binding level,
1314      rather than the end.  This hack is no longer used.  */
1315   my_friendly_assert (keep == 0 || keep == 1, 0);
1316
1317   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1318                       (HOST_WIDE_INT) current_binding_level->level_chain,
1319                       current_binding_level->parm_flag,
1320                       current_binding_level->keep);
1321
1322   if (current_binding_level->keep == 1)
1323     keep = 1;
1324
1325   /* Any uses of undefined labels, and any defined labels, now operate
1326      under constraints of next binding contour.  */
1327   if (cfun && !functionbody)
1328     {
1329       struct binding_level *level_chain;
1330       level_chain = current_binding_level->level_chain;
1331       if (level_chain)
1332         {
1333           struct named_label_use_list *uses;
1334           struct named_label_list *labels;
1335           for (labels = named_labels; labels; labels = labels->next)
1336             if (labels->binding_level == current_binding_level)
1337               {
1338                 tree decl;
1339                 if (current_binding_level->eh_region)
1340                   labels->eh_region = 1;
1341                 for (decl = labels->names_in_scope; decl;
1342                      decl = TREE_CHAIN (decl))
1343                   if (decl_jump_unsafe (decl))
1344                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1345                                                    labels->bad_decls);
1346                 labels->binding_level = level_chain;
1347                 labels->names_in_scope = level_chain->names;
1348               }
1349
1350           for (uses = named_label_uses; uses; uses = uses->next)
1351             if (uses->binding_level == current_binding_level)
1352               {
1353                 uses->binding_level = level_chain;
1354                 uses->names_in_scope = level_chain->names;
1355               }
1356         }
1357     }
1358
1359   /* Get the decls in the order they were written.
1360      Usually current_binding_level->names is in reverse order.
1361      But parameter decls were previously put in forward order.  */
1362
1363   if (reverse)
1364     current_binding_level->names
1365       = decls = nreverse (current_binding_level->names);
1366   else
1367     decls = current_binding_level->names;
1368
1369   /* Output any nested inline functions within this block
1370      if they weren't already output.  */
1371   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1372     if (TREE_CODE (decl) == FUNCTION_DECL
1373         && ! TREE_ASM_WRITTEN (decl)
1374         && DECL_INITIAL (decl) != NULL_TREE
1375         && TREE_ADDRESSABLE (decl)
1376         && decl_function_context (decl) == current_function_decl)
1377       {
1378         /* If this decl was copied from a file-scope decl
1379            on account of a block-scope extern decl,
1380            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1381         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1382           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1383         else
1384           {
1385             push_function_context ();
1386             output_inline_function (decl);
1387             pop_function_context ();
1388           }
1389       }
1390
1391   /* When not in function-at-a-time mode, expand_end_bindings will
1392      warn about unused variables.  But, in function-at-a-time mode
1393      expand_end_bindings is not passed the list of variables in the
1394      current scope, and therefore no warning is emitted.  So, we
1395      explicitly warn here.  */
1396   if (!processing_template_decl)
1397     warn_about_unused_variables (getdecls ());
1398
1399   /* If there were any declarations or structure tags in that level,
1400      or if this level is a function body,
1401      create a BLOCK to record them for the life of this function.  */
1402   block = NULL_TREE;
1403   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1404   if (block_previously_created)
1405     block = current_binding_level->this_block;
1406   else if (keep == 1 || functionbody)
1407     block = make_node (BLOCK);
1408   if (block != NULL_TREE)
1409     {
1410       if (block_previously_created)
1411         {
1412           if (decls || tags || subblocks)
1413             {
1414               if (BLOCK_VARS (block))
1415                 warning ("internal compiler error: debugging info corrupted");
1416
1417               BLOCK_VARS (block) = decls;
1418
1419               /* We can have previous subblocks and new subblocks when
1420                  doing fixup_gotos with complex cleanups.  We chain the new
1421                  subblocks onto the end of any pre-existing subblocks.  */
1422               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1423                                                  subblocks);
1424             }
1425         }
1426       else
1427         {
1428           BLOCK_VARS (block) = decls;
1429           BLOCK_SUBBLOCKS (block) = subblocks;
1430         }
1431     }
1432
1433   /* In each subblock, record that this is its superior.  */
1434   if (keep >= 0)
1435     for (link = subblocks; link; link = TREE_CHAIN (link))
1436       BLOCK_SUPERCONTEXT (link) = block;
1437
1438   /* We still support the old for-scope rules, whereby the variables
1439      in a for-init statement were in scope after the for-statement
1440      ended.  We only use the new rules in flag_new_for_scope is
1441      nonzero.  */
1442   leaving_for_scope
1443     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1444
1445   /* Remove declarations for all the DECLs in this level.  */
1446   for (link = decls; link; link = TREE_CHAIN (link))
1447     {
1448       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1449           && DECL_NAME (link))
1450         {
1451           tree outer_binding
1452             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1453           tree ns_binding;
1454
1455           if (!outer_binding)
1456             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1457           else
1458             ns_binding = NULL_TREE;
1459
1460           if (outer_binding
1461               && (BINDING_LEVEL (outer_binding)
1462                   == current_binding_level->level_chain))
1463             /* We have something like:
1464
1465                  int i;
1466                  for (int i; ;);
1467
1468                and we are leaving the `for' scope.  There's no reason to
1469                keep the binding of the inner `i' in this case.  */
1470             pop_binding (DECL_NAME (link), link);
1471           else if ((outer_binding
1472                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1473                         == TYPE_DECL))
1474                    || (ns_binding
1475                        && TREE_CODE (ns_binding) == TYPE_DECL))
1476             /* Here, we have something like:
1477
1478                  typedef int I;
1479
1480                  void f () {
1481                    for (int I; ;);
1482                  }
1483
1484                We must pop the for-scope binding so we know what's a
1485                type and what isn't.  */
1486             pop_binding (DECL_NAME (link), link);
1487           else
1488             {
1489               /* Mark this VAR_DECL as dead so that we can tell we left it
1490                  there only for backward compatibility.  */
1491               DECL_DEAD_FOR_LOCAL (link) = 1;
1492
1493               /* Keep track of what should of have happenned when we
1494                  popped the binding.  */
1495               if (outer_binding && BINDING_VALUE (outer_binding))
1496                 DECL_SHADOWED_FOR_VAR (link)
1497                   = BINDING_VALUE (outer_binding);
1498
1499               /* Add it to the list of dead variables in the next
1500                  outermost binding to that we can remove these when we
1501                  leave that binding.  */
1502               current_binding_level->level_chain->dead_vars_from_for
1503                 = tree_cons (NULL_TREE, link,
1504                              current_binding_level->level_chain->
1505                              dead_vars_from_for);
1506
1507               /* Although we don't pop the CPLUS_BINDING, we do clear
1508                  its BINDING_LEVEL since the level is going away now.  */
1509               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1510                 = 0;
1511             }
1512         }
1513       else
1514         {
1515           /* Remove the binding.  */
1516           decl = link;
1517           if (TREE_CODE (decl) == TREE_LIST)
1518             decl = TREE_VALUE (decl);
1519           if (DECL_P (decl))
1520             pop_binding (DECL_NAME (decl), decl);
1521           else if (TREE_CODE (decl) == OVERLOAD)
1522             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1523           else
1524             my_friendly_abort (0);
1525         }
1526     }
1527
1528   /* Remove declarations for any `for' variables from inner scopes
1529      that we kept around.  */
1530   for (link = current_binding_level->dead_vars_from_for;
1531        link; link = TREE_CHAIN (link))
1532     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1533
1534   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1535   for (link = current_binding_level->type_shadowed;
1536        link; link = TREE_CHAIN (link))
1537     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1538
1539   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1540   for (link = current_binding_level->shadowed_labels;
1541        link;
1542        link = TREE_CHAIN (link))
1543     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1544
1545   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1546      list if a `using' declaration put them there.  The debugging
1547      back-ends won't understand OVERLOAD, so we remove them here.
1548      Because the BLOCK_VARS are (temporarily) shared with
1549      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1550      popped all the bindings.  */
1551   if (block)
1552     {
1553       tree* d;
1554
1555       for (d = &BLOCK_VARS (block); *d; )
1556         {
1557           if (TREE_CODE (*d) == TREE_LIST)
1558             *d = TREE_CHAIN (*d);
1559           else
1560             d = &TREE_CHAIN (*d);
1561         }
1562     }
1563
1564   /* If the level being exited is the top level of a function,
1565      check over all the labels.  */
1566   if (functionbody)
1567     {
1568       /* Since this is the top level block of a function, the vars are
1569          the function's parameters.  Don't leave them in the BLOCK
1570          because they are found in the FUNCTION_DECL instead.  */
1571       BLOCK_VARS (block) = 0;
1572       pop_labels (block);
1573     }
1574
1575   tmp = current_binding_level->keep;
1576
1577   pop_binding_level ();
1578   if (functionbody)
1579     DECL_INITIAL (current_function_decl) = block;
1580   else if (block)
1581     {
1582       if (!block_previously_created)
1583         current_binding_level->blocks
1584           = chainon (current_binding_level->blocks, block);
1585     }
1586   /* If we did not make a block for the level just exited,
1587      any blocks made for inner levels
1588      (since they cannot be recorded as subblocks in that level)
1589      must be carried forward so they will later become subblocks
1590      of something else.  */
1591   else if (subblocks)
1592     current_binding_level->blocks
1593       = chainon (current_binding_level->blocks, subblocks);
1594
1595   /* Each and every BLOCK node created here in `poplevel' is important
1596      (e.g. for proper debugging information) so if we created one
1597      earlier, mark it as "used".  */
1598   if (block)
1599     TREE_USED (block) = 1;
1600
1601   /* Take care of compiler's internal binding structures.  */
1602   if (tmp == 2)
1603     {
1604       tree scope_stmts;
1605
1606       scope_stmts
1607         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1608       if (block)
1609         {
1610           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1611           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1612         }
1613
1614       block = poplevel (keep, reverse, functionbody);
1615     }
1616
1617   return block;
1618 }
1619
1620 /* Delete the node BLOCK from the current binding level.
1621    This is used for the block inside a stmt expr ({...})
1622    so that the block can be reinserted where appropriate.  */
1623
1624 void
1625 delete_block (block)
1626      tree block;
1627 {
1628   tree t;
1629   if (current_binding_level->blocks == block)
1630     current_binding_level->blocks = TREE_CHAIN (block);
1631   for (t = current_binding_level->blocks; t;)
1632     {
1633       if (TREE_CHAIN (t) == block)
1634         TREE_CHAIN (t) = TREE_CHAIN (block);
1635       else
1636         t = TREE_CHAIN (t);
1637     }
1638   TREE_CHAIN (block) = NULL_TREE;
1639   /* Clear TREE_USED which is always set by poplevel.
1640      The flag is set again if insert_block is called.  */
1641   TREE_USED (block) = 0;
1642 }
1643
1644 /* Insert BLOCK at the end of the list of subblocks of the
1645    current binding level.  This is used when a BIND_EXPR is expanded,
1646    to handle the BLOCK node inside the BIND_EXPR.  */
1647
1648 void
1649 insert_block (block)
1650      tree block;
1651 {
1652   TREE_USED (block) = 1;
1653   current_binding_level->blocks
1654     = chainon (current_binding_level->blocks, block);
1655 }
1656
1657 /* Set the BLOCK node for the innermost scope
1658    (the one we are currently in).  */
1659
1660 void
1661 set_block (block)
1662     register tree block;
1663 {
1664   current_binding_level->this_block = block;
1665 }
1666
1667 /* Do a pushlevel for class declarations.  */
1668
1669 void
1670 pushlevel_class ()
1671 {
1672   register struct binding_level *newlevel;
1673
1674   /* Reuse or create a struct for this binding level.  */
1675 #if defined(DEBUG_CP_BINDING_LEVELS)
1676   if (0)
1677 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1678   if (free_binding_level)
1679 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1680     {
1681       newlevel = free_binding_level;
1682       free_binding_level = free_binding_level->level_chain;
1683     }
1684   else
1685     newlevel = make_binding_level ();
1686
1687 #if defined(DEBUG_CP_BINDING_LEVELS)
1688   is_class_level = 1;
1689 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1690
1691   push_binding_level (newlevel, 0, 0);
1692
1693   class_binding_level = current_binding_level;
1694   class_binding_level->parm_flag = 2;
1695   class_binding_level->this_class = current_class_type;
1696 }
1697
1698 /* ...and a poplevel for class declarations.  */
1699
1700 void
1701 poplevel_class ()
1702 {
1703   register struct binding_level *level = class_binding_level;
1704   tree shadowed;
1705
1706   my_friendly_assert (level != 0, 354);
1707
1708   /* If we're leaving a toplevel class, don't bother to do the setting
1709      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1710      shouldn't even be used when current_class_type isn't set, and second,
1711      if we don't touch it here, we're able to use the cache effect if the
1712      next time we're entering a class scope, it is the same class.  */
1713   if (current_class_depth != 1)
1714     {
1715       struct binding_level* b;
1716
1717       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1718       for (shadowed = level->class_shadowed;
1719            shadowed;
1720            shadowed = TREE_CHAIN (shadowed))
1721         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1722
1723       /* Find the next enclosing class, and recreate
1724          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1725       b = level->level_chain;
1726       while (b && b->parm_flag != 2)
1727         b = b->level_chain;
1728
1729       if (b)
1730         for (shadowed = b->class_shadowed;
1731              shadowed;
1732              shadowed = TREE_CHAIN (shadowed))
1733           {
1734             tree t;
1735
1736             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1737             while (t && BINDING_LEVEL (t) != b)
1738               t = TREE_CHAIN (t);
1739
1740             if (t)
1741               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1742                 = BINDING_VALUE (t);
1743           }
1744     }
1745   else
1746     /* Remember to save what IDENTIFIER's were bound in this scope so we
1747        can recover from cache misses.  */
1748     {
1749       previous_class_type = current_class_type;
1750       previous_class_values = class_binding_level->class_shadowed;
1751     }
1752   for (shadowed = level->type_shadowed;
1753        shadowed;
1754        shadowed = TREE_CHAIN (shadowed))
1755     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1756
1757   /* Remove the bindings for all of the class-level declarations.  */
1758   for (shadowed = level->class_shadowed;
1759        shadowed;
1760        shadowed = TREE_CHAIN (shadowed))
1761     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1762
1763   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1764                       (HOST_WIDE_INT) class_binding_level->level_chain,
1765                       class_binding_level->parm_flag,
1766                       class_binding_level->keep);
1767
1768   /* Now, pop out of the binding level which we created up in the
1769      `pushlevel_class' routine.  */
1770 #if defined(DEBUG_CP_BINDING_LEVELS)
1771   is_class_level = 1;
1772 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1773
1774   pop_binding_level ();
1775 }
1776
1777 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1778    for any names in enclosing classes.  */
1779
1780 void
1781 clear_identifier_class_values ()
1782 {
1783   tree t;
1784
1785   if (!class_binding_level)
1786     return;
1787
1788   for (t = class_binding_level->class_shadowed;
1789        t;
1790        t = TREE_CHAIN (t))
1791     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1792 }
1793
1794 /* Returns non-zero if T is a virtual function table.  */
1795
1796 int
1797 vtable_decl_p (t, data)
1798      tree t;
1799      void *data ATTRIBUTE_UNUSED;
1800 {
1801   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1802 }
1803
1804 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1805    functions.  */
1806
1807 int
1808 vtype_decl_p (t, data)
1809      tree t;
1810      void *data ATTRIBUTE_UNUSED;
1811 {
1812   return (TREE_CODE (t) == TYPE_DECL
1813           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1814           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1815 }
1816
1817 /* Return the declarations that are members of the namespace NS.  */
1818
1819 tree
1820 cp_namespace_decls (ns)
1821      tree ns;
1822 {
1823   return NAMESPACE_LEVEL (ns)->names;
1824 }
1825
1826 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1827    itself, calling F for each.  The DATA is passed to F as well.  */
1828
1829 static int
1830 walk_namespaces_r (namespace, f, data)
1831      tree namespace;
1832      walk_namespaces_fn f;
1833      void *data;
1834 {
1835   tree current;
1836   int result = 0;
1837
1838   result |= (*f) (namespace, data);
1839
1840   for (current = cp_namespace_decls (namespace);
1841        current;
1842        current = TREE_CHAIN (current))
1843     {
1844       if (TREE_CODE (current) != NAMESPACE_DECL
1845           || DECL_NAMESPACE_ALIAS (current))
1846         continue;
1847       if (!DECL_LANG_SPECIFIC (current))
1848         {
1849           /* Hmm. std. */
1850           my_friendly_assert (current == std_node, 393);
1851           continue;
1852         }
1853
1854       /* We found a namespace.  */
1855       result |= walk_namespaces_r (current, f, data);
1856     }
1857
1858   return result;
1859 }
1860
1861 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1862    F as well.  */
1863
1864 int
1865 walk_namespaces (f, data)
1866      walk_namespaces_fn f;
1867      void *data;
1868 {
1869   return walk_namespaces_r (global_namespace, f, data);
1870 }
1871
1872 struct walk_globals_data {
1873   walk_globals_pred p;
1874   walk_globals_fn f;
1875   void *data;
1876 };
1877
1878 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1879    for which P returns non-zero, call F with its address.  If any call
1880    to F returns a non-zero value, return a non-zero value.  */
1881
1882 static int
1883 walk_globals_r (namespace, data)
1884      tree namespace;
1885      void *data;
1886 {
1887   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1888   walk_globals_pred p = wgd->p;
1889   walk_globals_fn f = wgd->f;
1890   void *d = wgd->data;
1891   tree *t;
1892   int result = 0;
1893
1894   t = &NAMESPACE_LEVEL (namespace)->names;
1895
1896   while (*t)
1897     {
1898       tree glbl = *t;
1899
1900       if ((*p) (glbl, d))
1901         result |= (*f) (t, d);
1902
1903       /* If F changed *T, then *T still points at the next item to
1904          examine.  */
1905       if (*t == glbl)
1906         t = &TREE_CHAIN (*t);
1907     }
1908
1909   return result;
1910 }
1911
1912 /* Walk the global declarations.  Whenever one is found for which P
1913    returns non-zero, call F with its address.  If any call to F
1914    returns a non-zero value, return a non-zero value.  */
1915
1916 int
1917 walk_globals (p, f, data)
1918      walk_globals_pred p;
1919      walk_globals_fn f;
1920      void *data;
1921 {
1922   struct walk_globals_data wgd;
1923   wgd.p = p;
1924   wgd.f = f;
1925   wgd.data = data;
1926
1927   return walk_namespaces (walk_globals_r, &wgd);
1928 }
1929
1930 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1931    DATA is non-NULL, this is the last time we will call
1932    wrapup_global_declarations for this NAMESPACE.  */
1933
1934 int
1935 wrapup_globals_for_namespace (namespace, data)
1936      tree namespace;
1937      void *data;
1938 {
1939   tree globals = cp_namespace_decls (namespace);
1940   int len = list_length (globals);
1941   tree *vec = (tree *) alloca (sizeof (tree) * len);
1942   int i;
1943   int result;
1944   tree decl;
1945   int last_time = (data != 0);
1946
1947   if (last_time && namespace == global_namespace)
1948     /* Let compile_file handle the global namespace.  */
1949     return 0;
1950
1951   /* Process the decls in reverse order--earliest first.
1952      Put them into VEC from back to front, then take out from front.  */
1953
1954   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1955     {
1956       /* Pretend we've output an unused static variable.  This ensures
1957          that the toplevel __FUNCTION__ etc won't be emitted, unless
1958          needed. */
1959       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1960           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1961         {
1962           TREE_ASM_WRITTEN (decl) = 1;
1963           DECL_IGNORED_P (decl) = 1;
1964         }
1965       vec[len - i - 1] = decl;
1966     }
1967
1968   if (last_time)
1969     {
1970       check_global_declarations (vec, len);
1971       return 0;
1972     }
1973
1974   /* Temporarily mark vtables as external.  That prevents
1975      wrapup_global_declarations from writing them out; we must process
1976      them ourselves in finish_vtable_vardecl.  */
1977   for (i = 0; i < len; ++i)
1978     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1979       {
1980         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1981         DECL_EXTERNAL (vec[i]) = 1;
1982       }
1983
1984   /* Write out any globals that need to be output.  */
1985   result = wrapup_global_declarations (vec, len);
1986
1987   /* Undo the hack to DECL_EXTERNAL above.  */
1988   for (i = 0; i < len; ++i)
1989     if (vtable_decl_p (vec[i], /*data=*/0)
1990         && DECL_NOT_REALLY_EXTERN (vec[i]))
1991       {
1992         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1993         DECL_EXTERNAL (vec[i]) = 0;
1994       }
1995
1996   return result;
1997 }
1998
1999 \f
2000 /* Mark ARG (which is really a struct binding_level **) for GC.  */
2001
2002 static void
2003 mark_binding_level (arg)
2004      void *arg;
2005 {
2006   struct binding_level *lvl = *(struct binding_level **)arg;
2007
2008   for (; lvl; lvl = lvl->level_chain)
2009     {
2010       ggc_mark_tree (lvl->names);
2011       ggc_mark_tree (lvl->tags);
2012       ggc_mark_tree (lvl->usings);
2013       ggc_mark_tree (lvl->using_directives);
2014       ggc_mark_tree (lvl->class_shadowed);
2015       ggc_mark_tree (lvl->type_shadowed);
2016       ggc_mark_tree (lvl->shadowed_labels);
2017       ggc_mark_tree (lvl->blocks);
2018       ggc_mark_tree (lvl->this_block);
2019       ggc_mark_tree (lvl->this_class);
2020       ggc_mark_tree (lvl->incomplete);
2021       ggc_mark_tree (lvl->dead_vars_from_for);
2022     }
2023 }
2024
2025 static void
2026 mark_named_label_lists (labs, uses)
2027      void *labs;
2028      void *uses;
2029 {
2030   struct named_label_list *l = *(struct named_label_list **)labs;
2031   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2032
2033   for (; l; l = l->next)
2034     {
2035       ggc_mark (l);
2036       mark_binding_level (l->binding_level);
2037       ggc_mark_tree (l->old_value);
2038       ggc_mark_tree (l->label_decl);
2039       ggc_mark_tree (l->bad_decls);
2040     }
2041
2042   for (; u; u = u->next)
2043     ggc_mark (u);
2044 }
2045 \f
2046 /* For debugging.  */
2047 static int no_print_functions = 0;
2048 static int no_print_builtins = 0;
2049
2050 void
2051 print_binding_level (lvl)
2052      struct binding_level *lvl;
2053 {
2054   tree t;
2055   int i = 0, len;
2056   fprintf (stderr, " blocks=");
2057   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2058   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2059            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2060   if (lvl->tag_transparent)
2061     fprintf (stderr, " tag-transparent");
2062   if (lvl->more_cleanups_ok)
2063     fprintf (stderr, " more-cleanups-ok");
2064   if (lvl->have_cleanups)
2065     fprintf (stderr, " have-cleanups");
2066   fprintf (stderr, "\n");
2067   if (lvl->names)
2068     {
2069       fprintf (stderr, " names:\t");
2070       /* We can probably fit 3 names to a line?  */
2071       for (t = lvl->names; t; t = TREE_CHAIN (t))
2072         {
2073           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2074             continue;
2075           if (no_print_builtins
2076               && (TREE_CODE (t) == TYPE_DECL)
2077               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2078             continue;
2079
2080           /* Function decls tend to have longer names.  */
2081           if (TREE_CODE (t) == FUNCTION_DECL)
2082             len = 3;
2083           else
2084             len = 2;
2085           i += len;
2086           if (i > 6)
2087             {
2088               fprintf (stderr, "\n\t");
2089               i = len;
2090             }
2091           print_node_brief (stderr, "", t, 0);
2092           if (t == error_mark_node)
2093             break;
2094         }
2095       if (i)
2096         fprintf (stderr, "\n");
2097     }
2098   if (lvl->tags)
2099     {
2100       fprintf (stderr, " tags:\t");
2101       i = 0;
2102       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2103         {
2104           if (TREE_PURPOSE (t) == NULL_TREE)
2105             len = 3;
2106           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2107             len = 2;
2108           else
2109             len = 4;
2110           i += len;
2111           if (i > 5)
2112             {
2113               fprintf (stderr, "\n\t");
2114               i = len;
2115             }
2116           if (TREE_PURPOSE (t) == NULL_TREE)
2117             {
2118               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2119               fprintf (stderr, ">");
2120             }
2121           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2122             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2123           else
2124             {
2125               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2126               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2127               fprintf (stderr, ">");
2128             }
2129         }
2130       if (i)
2131         fprintf (stderr, "\n");
2132     }
2133   if (lvl->class_shadowed)
2134     {
2135       fprintf (stderr, " class-shadowed:");
2136       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2137         {
2138           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2139         }
2140       fprintf (stderr, "\n");
2141     }
2142   if (lvl->type_shadowed)
2143     {
2144       fprintf (stderr, " type-shadowed:");
2145       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2146         {
2147           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2148         }
2149       fprintf (stderr, "\n");
2150     }
2151 }
2152
2153 void
2154 print_other_binding_stack (stack)
2155      struct binding_level *stack;
2156 {
2157   struct binding_level *level;
2158   for (level = stack; level != global_binding_level; level = level->level_chain)
2159     {
2160       fprintf (stderr, "binding level ");
2161       fprintf (stderr, HOST_PTR_PRINTF, level);
2162       fprintf (stderr, "\n");
2163       print_binding_level (level);
2164     }
2165 }
2166
2167 void
2168 print_binding_stack ()
2169 {
2170   struct binding_level *b;
2171   fprintf (stderr, "current_binding_level=");
2172   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2173   fprintf (stderr, "\nclass_binding_level=");
2174   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2175   fprintf (stderr, "\nglobal_binding_level=");
2176   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2177   fprintf (stderr, "\n");
2178   if (class_binding_level)
2179     {
2180       for (b = class_binding_level; b; b = b->level_chain)
2181         if (b == current_binding_level)
2182           break;
2183       if (b)
2184         b = class_binding_level;
2185       else
2186         b = current_binding_level;
2187     }
2188   else
2189     b = current_binding_level;
2190   print_other_binding_stack (b);
2191   fprintf (stderr, "global:\n");
2192   print_binding_level (global_binding_level);
2193 }
2194
2195 /* Namespace binding access routines: The namespace_bindings field of
2196    the identifier is polymorphic, with three possible values:
2197    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2198    indicating the BINDING_VALUE of global_namespace. */
2199
2200 /* Check whether the a binding for the name to scope is known.
2201    Assumes that the bindings of the name are already a list
2202    of bindings. Returns the binding found, or NULL_TREE. */
2203
2204 static tree
2205 find_binding (name, scope)
2206      tree name;
2207      tree scope;
2208 {
2209   tree iter, prev = NULL_TREE;
2210
2211   scope = ORIGINAL_NAMESPACE (scope);
2212
2213   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2214        iter = TREE_CHAIN (iter))
2215     {
2216       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2217       if (BINDING_SCOPE (iter) == scope)
2218         {
2219           /* Move binding found to the front of the list, so
2220              subsequent lookups will find it faster. */
2221           if (prev)
2222             {
2223               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2224               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2225               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2226             }
2227           return iter;
2228         }
2229       prev = iter;
2230     }
2231   return NULL_TREE;
2232 }
2233
2234 /* Always returns a binding for name in scope. If the
2235    namespace_bindings is not a list, convert it to one first.
2236    If no binding is found, make a new one. */
2237
2238 tree
2239 binding_for_name (name, scope)
2240      tree name;
2241      tree scope;
2242 {
2243   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2244   tree result;
2245
2246   scope = ORIGINAL_NAMESPACE (scope);
2247
2248   if (b && TREE_CODE (b) != CPLUS_BINDING)
2249     {
2250       /* Get rid of optimization for global scope. */
2251       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2252       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2253       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2254     }
2255   if (b && (result = find_binding (name, scope)))
2256     return result;
2257   /* Not found, make a new one. */
2258   result = make_node (CPLUS_BINDING);
2259   TREE_CHAIN (result) = b;
2260   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2261   BINDING_SCOPE (result) = scope;
2262   BINDING_TYPE (result) = NULL_TREE;
2263   BINDING_VALUE (result) = NULL_TREE;
2264   return result;
2265 }
2266
2267 /* Return the binding value for name in scope, considering that
2268    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2269
2270 tree
2271 namespace_binding (name, scope)
2272      tree name;
2273      tree scope;
2274 {
2275   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2276   if (b == NULL_TREE)
2277     return NULL_TREE;
2278   if (scope == NULL_TREE)
2279     scope = global_namespace;
2280   if (TREE_CODE (b) != CPLUS_BINDING)
2281     return (scope == global_namespace) ? b : NULL_TREE;
2282   name = find_binding (name,scope);
2283   if (name == NULL_TREE)
2284     return name;
2285   return BINDING_VALUE (name);
2286 }
2287
2288 /* Set the binding value for name in scope. If modifying the binding
2289    of global_namespace is attempted, try to optimize it. */
2290
2291 void
2292 set_namespace_binding (name, scope, val)
2293      tree name;
2294      tree scope;
2295      tree val;
2296 {
2297   tree b;
2298
2299   if (scope == NULL_TREE)
2300     scope = global_namespace;
2301
2302   if (scope == global_namespace)
2303     {
2304       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2305       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2306         {
2307           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2308           return;
2309         }
2310     }
2311   b = binding_for_name (name, scope);
2312   BINDING_VALUE (b) = val;
2313 }
2314
2315 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2316    select a name that is unique to this compilation unit.  */
2317
2318 void
2319 push_namespace (name)
2320      tree name;
2321 {
2322   tree d = NULL_TREE;
2323   int need_new = 1;
2324   int implicit_use = 0;
2325   int global = 0;
2326   if (!global_namespace)
2327     {
2328       /* This must be ::. */
2329       my_friendly_assert (name == get_identifier ("::"), 377);
2330       global = 1;
2331     }
2332   else if (!name)
2333     {
2334       /* The name of anonymous namespace is unique for the translation
2335          unit.  */
2336       if (!anonymous_namespace_name)
2337         anonymous_namespace_name = get_file_function_name ('N');
2338       name = anonymous_namespace_name;
2339       d = IDENTIFIER_NAMESPACE_VALUE (name);
2340       if (d)
2341         /* Reopening anonymous namespace.  */
2342         need_new = 0;
2343       implicit_use = 1;
2344     }
2345   else if (current_namespace == global_namespace
2346            && name == DECL_NAME (std_node))
2347     {
2348       in_std++;
2349       return;
2350     }
2351   else
2352     {
2353       /* Check whether this is an extended namespace definition. */
2354       d = IDENTIFIER_NAMESPACE_VALUE (name);
2355       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2356         {
2357           need_new = 0;
2358           if (DECL_NAMESPACE_ALIAS (d))
2359             {
2360               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2361                         d, DECL_NAMESPACE_ALIAS (d));
2362               d = DECL_NAMESPACE_ALIAS (d);
2363             }
2364         }
2365     }
2366
2367   if (need_new)
2368     {
2369       /* Make a new namespace, binding the name to it. */
2370       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2371       /* The global namespace is not pushed, and the global binding
2372          level is set elsewhere.  */
2373       if (!global)
2374         {
2375           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2376           d = pushdecl (d);
2377           pushlevel (0);
2378           declare_namespace_level ();
2379           NAMESPACE_LEVEL (d) = current_binding_level;
2380         }
2381     }
2382   else
2383     resume_binding_level (NAMESPACE_LEVEL (d));
2384
2385   if (implicit_use)
2386     do_using_directive (d);
2387   /* Enter the name space. */
2388   current_namespace = d;
2389 }
2390
2391 /* Pop from the scope of the current namespace.  */
2392
2393 void
2394 pop_namespace ()
2395 {
2396   if (current_namespace == global_namespace)
2397     {
2398       my_friendly_assert (in_std>0, 980421);
2399       in_std--;
2400       return;
2401     }
2402   current_namespace = CP_DECL_CONTEXT (current_namespace);
2403   /* The binding level is not popped, as it might be re-opened later.  */
2404   suspend_binding_level ();
2405 }
2406
2407 /* Push into the scope of the namespace NS, even if it is deeply
2408    nested within another namespace.  */
2409
2410 void
2411 push_nested_namespace (ns)
2412      tree ns;
2413 {
2414   if (ns == global_namespace)
2415     push_to_top_level ();
2416   else
2417     {
2418       push_nested_namespace (CP_DECL_CONTEXT (ns));
2419       push_namespace (DECL_NAME (ns));
2420     }
2421 }
2422
2423 /* Pop back from the scope of the namespace NS, which was previously
2424    entered with push_nested_namespace.  */
2425
2426 void
2427 pop_nested_namespace (ns)
2428      tree ns;
2429 {
2430   while (ns != global_namespace)
2431     {
2432       pop_namespace ();
2433       ns = CP_DECL_CONTEXT (ns);
2434     }
2435
2436   pop_from_top_level ();
2437 }
2438
2439 \f
2440 /* Subroutines for reverting temporarily to top-level for instantiation
2441    of templates and such.  We actually need to clear out the class- and
2442    local-value slots of all identifiers, so that only the global values
2443    are at all visible.  Simply setting current_binding_level to the global
2444    scope isn't enough, because more binding levels may be pushed.  */
2445 struct saved_scope *scope_chain;
2446
2447 /* Mark ST for GC.  */
2448
2449 static void
2450 mark_stmt_tree (st)
2451      struct stmt_tree *st;
2452 {
2453   ggc_mark_tree (st->x_last_stmt);
2454   ggc_mark_tree (st->x_last_expr_type);
2455 }
2456
2457 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2458
2459 static void
2460 mark_saved_scope (arg)
2461      void *arg;
2462 {
2463   struct saved_scope *t = *(struct saved_scope **)arg;
2464   while (t)
2465     {
2466       mark_binding_level (&t->class_bindings);
2467       ggc_mark_tree (t->old_bindings);
2468       ggc_mark_tree (t->old_namespace);
2469       ggc_mark_tree (t->class_name);
2470       ggc_mark_tree (t->class_type);
2471       ggc_mark_tree (t->access_specifier);
2472       ggc_mark_tree (t->function_decl);
2473       if (t->lang_base)
2474         ggc_mark_tree_varray (t->lang_base);
2475       ggc_mark_tree (t->lang_name);
2476       ggc_mark_tree (t->x_function_parms);
2477       ggc_mark_tree (t->template_parms);
2478       ggc_mark_tree (t->x_previous_class_type);
2479       ggc_mark_tree (t->x_previous_class_values);
2480       ggc_mark_tree (t->x_saved_tree);
2481       ggc_mark_tree (t->incomplete);
2482       ggc_mark_tree (t->lookups);
2483
2484       mark_stmt_tree (&t->x_stmt_tree);
2485       mark_binding_level (&t->bindings);
2486       t = t->prev;
2487     }
2488 }
2489
2490 static tree
2491 store_bindings (names, old_bindings)
2492      tree names, old_bindings;
2493 {
2494   tree t;
2495   for (t = names; t; t = TREE_CHAIN (t))
2496     {
2497       tree binding, t1, id;
2498
2499       if (TREE_CODE (t) == TREE_LIST)
2500         id = TREE_PURPOSE (t);
2501       else
2502         id = DECL_NAME (t);
2503
2504       if (!id
2505           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2506              we have no IDENTIFIER_BINDING if we have left the class
2507              scope, but cached the class-level declarations.  */
2508           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2509         continue;
2510
2511       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2512         if (TREE_VEC_ELT (t1, 0) == id)
2513           goto skip_it;
2514
2515       binding = make_tree_vec (4);
2516
2517       if (id)
2518         {
2519           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2520           TREE_VEC_ELT (binding, 0) = id;
2521           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2522           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2523           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2524           IDENTIFIER_BINDING (id) = NULL_TREE;
2525           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2526         }
2527       TREE_CHAIN (binding) = old_bindings;
2528       old_bindings = binding;
2529     skip_it:
2530       ;
2531     }
2532   return old_bindings;
2533 }
2534
2535 void
2536 maybe_push_to_top_level (pseudo)
2537      int pseudo;
2538 {
2539   struct saved_scope *s;
2540   struct binding_level *b;
2541   tree old_bindings;
2542   int need_pop;
2543
2544   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2545
2546   b = scope_chain ? current_binding_level : 0;
2547
2548   /* If we're in the middle of some function, save our state.  */
2549   if (cfun)
2550     {
2551       need_pop = 1;
2552       push_function_context_to (NULL_TREE);
2553     }
2554   else
2555     need_pop = 0;
2556
2557   old_bindings = NULL_TREE;
2558   if (scope_chain && previous_class_type)
2559     old_bindings = store_bindings (previous_class_values, old_bindings);
2560
2561   /* Have to include global_binding_level, because class-level decls
2562      aren't listed anywhere useful.  */
2563   for (; b; b = b->level_chain)
2564     {
2565       tree t;
2566
2567       /* Template IDs are inserted into the global level. If they were
2568          inserted into namespace level, finish_file wouldn't find them
2569          when doing pending instantiations. Therefore, don't stop at
2570          namespace level, but continue until :: .  */
2571       if (b == global_binding_level || (pseudo && b->template_parms_p))
2572         break;
2573
2574       old_bindings = store_bindings (b->names, old_bindings);
2575       /* We also need to check class_shadowed to save class-level type
2576          bindings, since pushclass doesn't fill in b->names.  */
2577       if (b->parm_flag == 2)
2578         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2579
2580       /* Unwind type-value slots back to top level.  */
2581       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2582         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2583     }
2584   s->prev = scope_chain;
2585   s->old_bindings = old_bindings;
2586   s->bindings = b;
2587   s->need_pop_function_context = need_pop;
2588   s->function_decl = current_function_decl;
2589
2590   scope_chain = s;
2591   current_function_decl = NULL_TREE;
2592   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2593   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2594   current_lang_name = lang_name_cplusplus;
2595   current_namespace = global_namespace;
2596 }
2597
2598 void
2599 push_to_top_level ()
2600 {
2601   maybe_push_to_top_level (0);
2602 }
2603
2604 void
2605 pop_from_top_level ()
2606 {
2607   struct saved_scope *s = scope_chain;
2608   tree t;
2609
2610   /* Clear out class-level bindings cache.  */
2611   if (previous_class_type)
2612     invalidate_class_lookup_cache ();
2613
2614   VARRAY_FREE (current_lang_base);
2615
2616   scope_chain = s->prev;
2617   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2618     {
2619       tree id = TREE_VEC_ELT (t, 0);
2620       if (id)
2621         {
2622           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2623           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2624           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2625         }
2626     }
2627
2628   /* If we were in the middle of compiling a function, restore our
2629      state.  */
2630   if (s->need_pop_function_context)
2631     pop_function_context_from (NULL_TREE);
2632   current_function_decl = s->function_decl;
2633
2634   free (s);
2635 }
2636 \f
2637 /* Push a definition of struct, union or enum tag "name".
2638    into binding_level "b".   "type" should be the type node,
2639    We assume that the tag "name" is not already defined.
2640
2641    Note that the definition may really be just a forward reference.
2642    In that case, the TYPE_SIZE will be a NULL_TREE.
2643
2644    C++ gratuitously puts all these tags in the name space.  */
2645
2646 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2647    record the shadowed value for this binding contour.  TYPE is
2648    the type that ID maps to.  */
2649
2650 static void
2651 set_identifier_type_value_with_scope (id, type, b)
2652      tree id;
2653      tree type;
2654      struct binding_level *b;
2655 {
2656   if (!b->namespace_p)
2657     {
2658       /* Shadow the marker, not the real thing, so that the marker
2659          gets restored later. */
2660       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2661       b->type_shadowed
2662         = tree_cons (id, old_type_value, b->type_shadowed);
2663     }
2664   else
2665     {
2666       tree binding = binding_for_name (id, current_namespace);
2667       BINDING_TYPE (binding) = type;
2668       /* Store marker instead of real type. */
2669       type = global_type_node;
2670     }
2671   SET_IDENTIFIER_TYPE_VALUE (id, type);
2672 }
2673
2674 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2675
2676 void
2677 set_identifier_type_value (id, type)
2678      tree id;
2679      tree type;
2680 {
2681   set_identifier_type_value_with_scope (id, type, current_binding_level);
2682 }
2683
2684 /* Return the type associated with id. */
2685
2686 tree
2687 identifier_type_value (id)
2688      tree id;
2689 {
2690   /* There is no type with that name, anywhere. */
2691   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2692     return NULL_TREE;
2693   /* This is not the type marker, but the real thing. */
2694   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2695     return REAL_IDENTIFIER_TYPE_VALUE (id);
2696   /* Have to search for it. It must be on the global level, now.
2697      Ask lookup_name not to return non-types. */
2698   id = lookup_name_real (id, 2, 1, 0);
2699   if (id)
2700     return TREE_TYPE (id);
2701   return NULL_TREE;
2702 }
2703
2704 /* Pop off extraneous binding levels left over due to syntax errors.
2705
2706    We don't pop past namespaces, as they might be valid.  */
2707
2708 void
2709 pop_everything ()
2710 {
2711 #ifdef DEBUG_CP_BINDING_LEVELS
2712   fprintf (stderr, "XXX entering pop_everything ()\n");
2713 #endif
2714   while (!toplevel_bindings_p ())
2715     {
2716       if (current_binding_level->parm_flag == 2)
2717         pop_nested_class ();
2718       else
2719         poplevel (0, 0, 0);
2720     }
2721 #ifdef DEBUG_CP_BINDING_LEVELS
2722   fprintf (stderr, "XXX leaving pop_everything ()\n");
2723 #endif
2724 }
2725
2726 /* The type TYPE is being declared.  If it is a class template, or a
2727    specialization of a class template, do any processing required and
2728    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2729    being declared a friend.  B is the binding level at which this TYPE
2730    should be bound.
2731
2732    Returns the TYPE_DECL for TYPE, which may have been altered by this
2733    processing.  */
2734
2735 static tree
2736 maybe_process_template_type_declaration (type, globalize, b)
2737      tree type;
2738      int globalize;
2739      struct binding_level* b;
2740 {
2741   tree decl = TYPE_NAME (type);
2742
2743   if (processing_template_parmlist)
2744     /* You can't declare a new template type in a template parameter
2745        list.  But, you can declare a non-template type:
2746
2747          template <class A*> struct S;
2748
2749        is a forward-declaration of `A'.  */
2750     ;
2751   else
2752     {
2753       maybe_check_template_type (type);
2754
2755       my_friendly_assert (IS_AGGR_TYPE (type)
2756                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2757
2758
2759       if (processing_template_decl)
2760         {
2761           /* This may change after the call to
2762              push_template_decl_real, but we want the original value.  */
2763           tree name = DECL_NAME (decl);
2764
2765           decl = push_template_decl_real (decl, globalize);
2766           /* If the current binding level is the binding level for the
2767              template parameters (see the comment in
2768              begin_template_parm_list) and the enclosing level is a class
2769              scope, and we're not looking at a friend, push the
2770              declaration of the member class into the class scope.  In the
2771              friend case, push_template_decl will already have put the
2772              friend into global scope, if appropriate.  */
2773           if (TREE_CODE (type) != ENUMERAL_TYPE
2774               && !globalize && b->template_parms_p
2775               && b->level_chain->parm_flag == 2)
2776             {
2777               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2778               /* Put this tag on the list of tags for the class, since
2779                  that won't happen below because B is not the class
2780                  binding level, but is instead the pseudo-global level.  */
2781               b->level_chain->tags =
2782                 tree_cons (name, type, b->level_chain->tags);
2783               if (!COMPLETE_TYPE_P (current_class_type))
2784                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2785             }
2786         }
2787     }
2788
2789   return decl;
2790 }
2791
2792 /* In C++, you don't have to write `struct S' to refer to `S'; you
2793    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2794    if the user had written `typedef struct S S'.  Create and return
2795    the TYPE_DECL for TYPE.  */
2796
2797 tree
2798 create_implicit_typedef (name, type)
2799      tree name;
2800      tree type;
2801 {
2802   tree decl;
2803
2804   decl = build_decl (TYPE_DECL, name, type);
2805   DECL_ARTIFICIAL (decl) = 1;
2806   /* There are other implicit type declarations, like the one *within*
2807      a class that allows you to write `S::S'.  We must distinguish
2808      amongst these.  */
2809   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2810   TYPE_NAME (type) = decl;
2811
2812   return decl;
2813 }
2814
2815 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2816    Normally put it into the inner-most non-tag-transparent scope,
2817    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2818    The latter is needed for implicit declarations.  */
2819
2820 void
2821 pushtag (name, type, globalize)
2822      tree name, type;
2823      int globalize;
2824 {
2825   register struct binding_level *b;
2826
2827   b = current_binding_level;
2828   while (b->tag_transparent
2829          || (globalize && b->parm_flag == 2))
2830     b = b->level_chain;
2831
2832   b->tags = tree_cons (name, type, b->tags);
2833
2834   if (name)
2835     {
2836       /* Do C++ gratuitous typedefing.  */
2837       if (IDENTIFIER_TYPE_VALUE (name) != type)
2838         {
2839           register tree d = NULL_TREE;
2840           int in_class = 0;
2841           tree context = TYPE_CONTEXT (type);
2842
2843           if (! context)
2844             {
2845               tree cs = current_scope ();
2846
2847               if (! globalize)
2848                 context = cs;
2849               else if (cs != NULL_TREE && TYPE_P (cs))
2850                 /* When declaring a friend class of a local class, we want
2851                    to inject the newly named class into the scope
2852                    containing the local class, not the namespace scope.  */
2853                 context = decl_function_context (get_type_decl (cs));
2854             }
2855           if (!context)
2856             context = current_namespace;
2857
2858           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2859               || b->parm_flag == 2)
2860             in_class = 1;
2861
2862           if (current_lang_name == lang_name_java)
2863             TYPE_FOR_JAVA (type) = 1;
2864
2865           d = create_implicit_typedef (name, type);
2866           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2867           if (! in_class)
2868             set_identifier_type_value_with_scope (name, type, b);
2869
2870           d = maybe_process_template_type_declaration (type,
2871                                                        globalize, b);
2872
2873           if (b->parm_flag == 2)
2874             {
2875               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2876                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2877                    class.  But if it's a member template class, we
2878                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2879                    is done later.  */
2880                 finish_member_declaration (d);
2881               else
2882                 pushdecl_class_level (d);
2883             }
2884           else
2885             d = pushdecl_with_scope (d, b);
2886
2887           if (ANON_AGGRNAME_P (name))
2888             DECL_IGNORED_P (d) = 1;
2889
2890           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2891           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2892
2893           /* If this is a local class, keep track of it.  We need this
2894              information for name-mangling, and so that it is possible to find
2895              all function definitions in a translation unit in a convenient
2896              way.  (It's otherwise tricky to find a member function definition
2897              it's only pointed to from within a local class.)  */
2898           if (TYPE_CONTEXT (type)
2899               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2900               && !processing_template_decl)
2901             VARRAY_PUSH_TREE (local_classes, type);
2902
2903           if (!uses_template_parms (type))
2904             {
2905               if (flag_new_abi)
2906                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2907               else
2908                 DECL_ASSEMBLER_NAME (d)
2909                   = get_identifier (build_overload_name (type, 1, 1));
2910             }
2911         }
2912       if (b->parm_flag == 2)
2913         {
2914           if (!COMPLETE_TYPE_P (current_class_type))
2915             CLASSTYPE_TAGS (current_class_type) = b->tags;
2916         }
2917     }
2918
2919   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2920     /* Use the canonical TYPE_DECL for this node.  */
2921     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2922   else
2923     {
2924       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2925          will be the tagged type we just added to the current
2926          binding level.  This fake NULL-named TYPE_DECL node helps
2927          dwarfout.c to know when it needs to output a
2928          representation of a tagged type, and it also gives us a
2929          convenient place to record the "scope start" address for
2930          the tagged type.  */
2931
2932       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2933       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2934     }
2935 }
2936
2937 /* Counter used to create anonymous type names.  */
2938
2939 static int anon_cnt = 0;
2940
2941 /* Return an IDENTIFIER which can be used as a name for
2942    anonymous structs and unions.  */
2943
2944 tree
2945 make_anon_name ()
2946 {
2947   char buf[32];
2948
2949   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2950   return get_identifier (buf);
2951 }
2952
2953 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2954    This keeps dbxout from getting confused.  */
2955
2956 void
2957 clear_anon_tags ()
2958 {
2959   register struct binding_level *b;
2960   register tree tags;
2961   static int last_cnt = 0;
2962
2963   /* Fast out if no new anon names were declared.  */
2964   if (last_cnt == anon_cnt)
2965     return;
2966
2967   b = current_binding_level;
2968   while (b->tag_transparent)
2969     b = b->level_chain;
2970   tags = b->tags;
2971   while (tags)
2972     {
2973       /* A NULL purpose means we have already processed all tags
2974          from here to the end of the list.  */
2975       if (TREE_PURPOSE (tags) == NULL_TREE)
2976         break;
2977       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2978         TREE_PURPOSE (tags) = NULL_TREE;
2979       tags = TREE_CHAIN (tags);
2980     }
2981   last_cnt = anon_cnt;
2982 }
2983 \f
2984 /* Subroutine of duplicate_decls: return truthvalue of whether
2985    or not types of these decls match.
2986
2987    For C++, we must compare the parameter list so that `int' can match
2988    `int&' in a parameter position, but `int&' is not confused with
2989    `const int&'.  */
2990
2991 int
2992 decls_match (newdecl, olddecl)
2993      tree newdecl, olddecl;
2994 {
2995   int types_match;
2996
2997   if (newdecl == olddecl)
2998     return 1;
2999
3000   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
3001     /* If the two DECLs are not even the same kind of thing, we're not
3002        interested in their types.  */
3003     return 0;
3004
3005   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3006     {
3007       tree f1 = TREE_TYPE (newdecl);
3008       tree f2 = TREE_TYPE (olddecl);
3009       tree p1 = TYPE_ARG_TYPES (f1);
3010       tree p2 = TYPE_ARG_TYPES (f2);
3011
3012       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3013           && ! (DECL_EXTERN_C_P (newdecl)
3014                 && DECL_EXTERN_C_P (olddecl)))
3015         return 0;
3016
3017       if (TREE_CODE (f1) != TREE_CODE (f2))
3018         return 0;
3019
3020       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3021         {
3022           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
3023               && (DECL_BUILT_IN (olddecl)
3024 #ifndef NO_IMPLICIT_EXTERN_C
3025                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
3026                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
3027 #endif
3028               ))
3029             {
3030               types_match = self_promoting_args_p (p1);
3031               if (p1 == void_list_node)
3032                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3033             }
3034 #ifndef NO_IMPLICIT_EXTERN_C
3035           else if (p1 == NULL_TREE
3036                    && (DECL_EXTERN_C_P (olddecl)
3037                        && DECL_IN_SYSTEM_HEADER (olddecl)
3038                        && !DECL_CLASS_SCOPE_P (olddecl))
3039                    && (DECL_EXTERN_C_P (newdecl)
3040                        && DECL_IN_SYSTEM_HEADER (newdecl)
3041                        && !DECL_CLASS_SCOPE_P (newdecl)))
3042             {
3043               types_match = self_promoting_args_p (p2);
3044               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3045             }
3046 #endif
3047           else
3048             types_match = compparms (p1, p2);
3049         }
3050       else
3051         types_match = 0;
3052     }
3053   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3054     {
3055       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3056                                 DECL_TEMPLATE_PARMS (olddecl)))
3057         return 0;
3058
3059       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3060           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3061         return 0;
3062
3063       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3064         types_match = 1;
3065       else
3066         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3067                                    DECL_TEMPLATE_RESULT (newdecl));
3068     }
3069   else
3070     {
3071       if (TREE_TYPE (newdecl) == error_mark_node)
3072         types_match = TREE_TYPE (olddecl) == error_mark_node;
3073       else if (TREE_TYPE (olddecl) == NULL_TREE)
3074         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3075       else if (TREE_TYPE (newdecl) == NULL_TREE)
3076         types_match = 0;
3077       else
3078         types_match = comptypes (TREE_TYPE (newdecl),
3079                                  TREE_TYPE (olddecl),
3080                                  COMPARE_REDECLARATION);
3081     }
3082
3083   return types_match;
3084 }
3085
3086 /* If NEWDECL is `static' and an `extern' was seen previously,
3087    warn about it.  OLDDECL is the previous declaration.
3088
3089    Note that this does not apply to the C++ case of declaring
3090    a variable `extern const' and then later `const'.
3091
3092    Don't complain about built-in functions, since they are beyond
3093    the user's control.  */
3094
3095 static void
3096 warn_extern_redeclared_static (newdecl, olddecl)
3097      tree newdecl, olddecl;
3098 {
3099   static const char *explicit_extern_static_warning
3100     = "`%D' was declared `extern' and later `static'";
3101   static const char *implicit_extern_static_warning
3102     = "`%D' was declared implicitly `extern' and later `static'";
3103
3104   tree name;
3105
3106   if (TREE_CODE (newdecl) == TYPE_DECL
3107       || TREE_CODE (newdecl) == TEMPLATE_DECL
3108       || TREE_CODE (newdecl) == CONST_DECL)
3109     return;
3110
3111   /* Don't get confused by static member functions; that's a different
3112      use of `static'.  */
3113   if (TREE_CODE (newdecl) == FUNCTION_DECL
3114       && DECL_STATIC_FUNCTION_P (newdecl))
3115     return;
3116
3117   /* If the old declaration was `static', or the new one isn't, then
3118      then everything is OK.  */
3119   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3120     return;
3121
3122   /* It's OK to declare a builtin function as `static'.  */
3123   if (TREE_CODE (olddecl) == FUNCTION_DECL
3124       && DECL_ARTIFICIAL (olddecl))
3125     return;
3126
3127   name = DECL_ASSEMBLER_NAME (newdecl);
3128   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3129               ? implicit_extern_static_warning
3130               : explicit_extern_static_warning, newdecl);
3131   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3132 }
3133
3134 /* Handle when a new declaration NEWDECL has the same name as an old
3135    one OLDDECL in the same binding contour.  Prints an error message
3136    if appropriate.
3137
3138    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3139    Otherwise, return 0.  */
3140
3141 int
3142 duplicate_decls (newdecl, olddecl)
3143      tree newdecl, olddecl;
3144 {
3145   unsigned olddecl_uid = DECL_UID (olddecl);
3146   int olddecl_friend = 0, types_match = 0;
3147   int new_defines_function = 0;
3148
3149   if (newdecl == olddecl)
3150     return 1;
3151
3152   types_match = decls_match (newdecl, olddecl);
3153
3154   /* If either the type of the new decl or the type of the old decl is an
3155      error_mark_node, then that implies that we have already issued an
3156      error (earlier) for some bogus type specification, and in that case,
3157      it is rather pointless to harass the user with yet more error message
3158      about the same declaration, so just pretend the types match here.  */
3159   if (TREE_TYPE (newdecl) == error_mark_node
3160       || TREE_TYPE (olddecl) == error_mark_node)
3161     types_match = 1;
3162
3163   /* Check for redeclaration and other discrepancies. */
3164   if (TREE_CODE (olddecl) == FUNCTION_DECL
3165       && DECL_ARTIFICIAL (olddecl))
3166     {
3167       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3168         {
3169           /* If you declare a built-in or predefined function name as static,
3170              the old definition is overridden, but optionally warn this was a
3171              bad choice of name.  */
3172           if (! TREE_PUBLIC (newdecl))
3173             {
3174               if (warn_shadow)
3175                 cp_warning ("shadowing %s function `%#D'",
3176                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3177                             olddecl);
3178               /* Discard the old built-in function.  */
3179               return 0;
3180             }
3181           /* If the built-in is not ansi, then programs can override
3182              it even globally without an error.  */
3183           else if (! DECL_BUILT_IN (olddecl))
3184             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3185                         olddecl, newdecl);
3186           else
3187             {
3188               cp_error ("declaration of `%#D'", newdecl);
3189               cp_error ("conflicts with built-in declaration `%#D'",
3190                         olddecl);
3191             }
3192           return 0;
3193         }
3194       else if (!types_match)
3195         {
3196           if ((DECL_EXTERN_C_P (newdecl)
3197                && DECL_EXTERN_C_P (olddecl))
3198               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3199                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3200             {
3201               /* A near match; override the builtin.  */
3202
3203               if (TREE_PUBLIC (newdecl))
3204                 {
3205                   cp_warning ("new declaration `%#D'", newdecl);
3206                   cp_warning ("ambiguates built-in declaration `%#D'",
3207                               olddecl);
3208                 }
3209               else if (warn_shadow)
3210                 cp_warning ("shadowing %s function `%#D'",
3211                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3212                             olddecl);
3213             }
3214           else
3215             /* Discard the old built-in function.  */
3216             return 0;
3217         }
3218
3219       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3220         {
3221           /* If a builtin function is redeclared as `static', merge
3222              the declarations, but make the original one static.  */
3223           DECL_THIS_STATIC (olddecl) = 1;
3224           TREE_PUBLIC (olddecl) = 0;
3225
3226           /* Make the old declaration consistent with the new one so
3227              that all remnants of the builtin-ness of this function
3228              will be banished.  */
3229           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3230           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3231           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3232           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3233                                        newdecl);
3234         }
3235     }
3236   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3237     {
3238       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3239            && TREE_CODE (newdecl) != TYPE_DECL
3240            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3241                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3242           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3243               && TREE_CODE (olddecl) != TYPE_DECL
3244               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3245                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3246                         == TYPE_DECL))))
3247         {
3248           /* We do nothing special here, because C++ does such nasty
3249              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3250              get shadowed, and know that if we need to find a TYPE_DECL
3251              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3252              slot of the identifier.  */
3253           return 0;
3254         }
3255
3256       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3257            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3258           || (TREE_CODE (olddecl) == FUNCTION_DECL
3259               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3260         return 0;
3261
3262       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3263       if (TREE_CODE (olddecl) == TREE_LIST)
3264         olddecl = TREE_VALUE (olddecl);
3265       cp_error_at ("previous declaration of `%#D'", olddecl);
3266
3267       /* New decl is completely inconsistent with the old one =>
3268          tell caller to replace the old one.  */
3269
3270       return 0;
3271     }
3272   else if (!types_match)
3273     {
3274       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3275         /* These are certainly not duplicate declarations; they're
3276            from different scopes.  */
3277         return 0;
3278
3279       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3280         {
3281           /* The name of a class template may not be declared to refer to
3282              any other template, class, function, object, namespace, value,
3283              or type in the same scope.  */
3284           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3285               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3286             {
3287               cp_error ("declaration of template `%#D'", newdecl);
3288               cp_error_at ("conflicts with previous declaration `%#D'",
3289                            olddecl);
3290             }
3291           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3292                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3293                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3294                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3295                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3296                                            DECL_TEMPLATE_PARMS (olddecl)))
3297             {
3298               cp_error ("new declaration `%#D'", newdecl);
3299               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3300             }
3301           return 0;
3302         }
3303       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3304         {
3305           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3306             {
3307               cp_error ("declaration of C function `%#D' conflicts with",
3308                         newdecl);
3309               cp_error_at ("previous declaration `%#D' here", olddecl);
3310             }
3311           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3312                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3313             {
3314               cp_error ("new declaration `%#D'", newdecl);
3315               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3316             }
3317           else
3318             return 0;
3319         }
3320
3321       /* Already complained about this, so don't do so again.  */
3322       else if (current_class_type == NULL_TREE
3323           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3324         {
3325           cp_error ("conflicting types for `%#D'", newdecl);
3326           cp_error_at ("previous declaration as `%#D'", olddecl);
3327         }
3328     }
3329   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3330             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3331                  && (!DECL_TEMPLATE_INFO (newdecl)
3332                      || (DECL_TI_TEMPLATE (newdecl)
3333                          != DECL_TI_TEMPLATE (olddecl))))
3334                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3335                     && (!DECL_TEMPLATE_INFO (olddecl)
3336                         || (DECL_TI_TEMPLATE (olddecl)
3337                             != DECL_TI_TEMPLATE (newdecl))))))
3338     /* It's OK to have a template specialization and a non-template
3339        with the same type, or to have specializations of two
3340        different templates with the same type.  Note that if one is a
3341        specialization, and the other is an instantiation of the same
3342        template, that we do not exit at this point.  That situation
3343        can occur if we instantiate a template class, and then
3344        specialize one of its methods.  This situation is legal, but
3345        the declarations must be merged in the usual way.  */
3346     return 0;
3347   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3348            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3349                 && !DECL_USE_TEMPLATE (newdecl))
3350                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3351                    && !DECL_USE_TEMPLATE (olddecl))))
3352     /* One of the declarations is a template instantiation, and the
3353        other is not a template at all.  That's OK.  */
3354     return 0;
3355   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3356            && DECL_NAMESPACE_ALIAS (newdecl)
3357            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3358     /* Redeclaration of namespace alias, ignore it. */
3359     return 1;
3360   else
3361     {
3362       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3363       if (errmsg)
3364         {
3365           cp_error (errmsg, newdecl);
3366           if (DECL_NAME (olddecl) != NULL_TREE)
3367             cp_error_at ((DECL_INITIAL (olddecl)
3368                           && namespace_bindings_p ())
3369                          ? "`%#D' previously defined here"
3370                          : "`%#D' previously declared here", olddecl);
3371         }
3372       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3373                && DECL_INITIAL (olddecl) != NULL_TREE
3374                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3375                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3376         {
3377           /* Prototype decl follows defn w/o prototype.  */
3378           cp_warning_at ("prototype for `%#D'", newdecl);
3379           cp_warning_at ("follows non-prototype definition here", olddecl);
3380         }
3381       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3382                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3383         {
3384           /* extern "C" int foo ();
3385              int foo () { bar (); }
3386              is OK.  */
3387           if (current_lang_stack
3388               == &VARRAY_TREE (current_lang_base, 0))
3389             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3390           else
3391             {
3392               cp_error_at ("previous declaration of `%#D' with %L linkage",
3393                            olddecl, DECL_LANGUAGE (olddecl));
3394               cp_error ("conflicts with new declaration with %L linkage",
3395                         DECL_LANGUAGE (newdecl));
3396             }
3397         }
3398
3399       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3400         ;
3401       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3402         {
3403           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3404           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3405           int i = 1;
3406
3407           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3408             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3409
3410           for (; t1 && t1 != void_list_node;
3411                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3412             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3413               {
3414                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3415                                            TREE_PURPOSE (t2)))
3416                   {
3417                     if (pedantic)
3418                       {
3419                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3420                                     i, newdecl);
3421                         cp_pedwarn_at ("after previous specification in `%#D'",
3422                                        olddecl);
3423                       }
3424                   }
3425                 else
3426                   {
3427                     cp_error ("default argument given for parameter %d of `%#D'",
3428                               i, newdecl);
3429                     cp_error_at ("after previous specification in `%#D'",
3430                                  olddecl);
3431                   }
3432               }
3433
3434           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3435               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3436             {
3437               cp_warning ("`%#D' was used before it was declared inline",
3438                           newdecl);
3439               cp_warning_at ("previous non-inline declaration here",
3440                              olddecl);
3441             }
3442         }
3443     }
3444
3445   /* If new decl is `static' and an `extern' was seen previously,
3446      warn about it.  */
3447   warn_extern_redeclared_static (newdecl, olddecl);
3448
3449   /* We have committed to returning 1 at this point.  */
3450   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3451     {
3452       /* Now that functions must hold information normally held
3453          by field decls, there is extra work to do so that
3454          declaration information does not get destroyed during
3455          definition.  */
3456       if (DECL_VINDEX (olddecl))
3457         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3458       if (DECL_VIRTUAL_CONTEXT (olddecl))
3459         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3460       if (DECL_CONTEXT (olddecl))
3461         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3462       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3463         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3464       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3465       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3466       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3467       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3468       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3469       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3470       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3471       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3472
3473       /* Optionally warn about more than one declaration for the same
3474          name, but don't warn about a function declaration followed by a
3475          definition.  */
3476       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3477           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3478           /* Don't warn about extern decl followed by definition. */
3479           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3480           /* Don't warn about friends, let add_friend take care of it. */
3481           && ! DECL_FRIEND_P (newdecl))
3482         {
3483           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3484           cp_warning_at ("previous declaration of `%D'", olddecl);
3485         }
3486     }
3487
3488   /* Deal with C++: must preserve virtual function table size.  */
3489   if (TREE_CODE (olddecl) == TYPE_DECL)
3490     {
3491       register tree newtype = TREE_TYPE (newdecl);
3492       register tree oldtype = TREE_TYPE (olddecl);
3493
3494       if (newtype != error_mark_node && oldtype != error_mark_node
3495           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3496         {
3497           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3498           CLASSTYPE_FRIEND_CLASSES (newtype)
3499             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3500         }
3501
3502       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3503     }
3504
3505   /* Copy all the DECL_... slots specified in the new decl
3506      except for any that we copy here from the old type.  */
3507   DECL_MACHINE_ATTRIBUTES (newdecl)
3508     = merge_machine_decl_attributes (olddecl, newdecl);
3509
3510   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3511     {
3512       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3513       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3514         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3515                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3516
3517       return 1;
3518     }
3519
3520   if (types_match)
3521     {
3522       /* Automatically handles default parameters.  */
3523       tree oldtype = TREE_TYPE (olddecl);
3524       tree newtype;
3525
3526       /* Merge the data types specified in the two decls.  */
3527       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3528
3529       /* If common_type produces a non-typedef type, just use the old type.  */
3530       if (TREE_CODE (newdecl) == TYPE_DECL
3531           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3532         newtype = oldtype;
3533
3534       if (TREE_CODE (newdecl) == VAR_DECL)
3535         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3536       /* Do this after calling `common_type' so that default
3537          parameters don't confuse us.  */
3538       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3539           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3540               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3541         {
3542           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3543                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3544           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3545                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3546
3547           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3548               && DECL_SOURCE_LINE (olddecl) != 0
3549               && flag_exceptions
3550               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3551                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3552             {
3553               cp_error ("declaration of `%F' throws different exceptions",
3554                         newdecl);
3555               cp_error_at ("than previous declaration `%F'", olddecl);
3556             }
3557         }
3558       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3559
3560       /* Lay the type out, unless already done.  */
3561       if (! same_type_p (newtype, oldtype)
3562           && TREE_TYPE (newdecl) != error_mark_node
3563           && !(processing_template_decl && uses_template_parms (newdecl)))
3564         layout_type (TREE_TYPE (newdecl));
3565
3566       if ((TREE_CODE (newdecl) == VAR_DECL
3567            || TREE_CODE (newdecl) == PARM_DECL
3568            || TREE_CODE (newdecl) == RESULT_DECL
3569            || TREE_CODE (newdecl) == FIELD_DECL
3570            || TREE_CODE (newdecl) == TYPE_DECL)
3571           && !(processing_template_decl && uses_template_parms (newdecl)))
3572         layout_decl (newdecl, 0);
3573
3574       /* Merge the type qualifiers.  */
3575       if (TREE_READONLY (newdecl))
3576         TREE_READONLY (olddecl) = 1;
3577       if (TREE_THIS_VOLATILE (newdecl))
3578         TREE_THIS_VOLATILE (olddecl) = 1;
3579
3580       /* Merge the initialization information.  */
3581       if (DECL_INITIAL (newdecl) == NULL_TREE
3582           && DECL_INITIAL (olddecl) != NULL_TREE)
3583         {
3584           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3585           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3586           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3587           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3588               && DECL_LANG_SPECIFIC (newdecl)
3589               && DECL_LANG_SPECIFIC (olddecl))
3590             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3591         }
3592
3593       /* Merge the section attribute.
3594          We want to issue an error if the sections conflict but that must be
3595          done later in decl_attributes since we are called before attributes
3596          are assigned.  */
3597       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3598         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3599
3600       /* Keep the old rtl since we can safely use it.  */
3601       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3602
3603       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3604         {
3605           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3606             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3607           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3608             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3609           DECL_NO_LIMIT_STACK (newdecl)
3610             |= DECL_NO_LIMIT_STACK (olddecl);
3611         }
3612     }
3613   /* If cannot merge, then use the new type and qualifiers,
3614      and don't preserve the old rtl.  */
3615   else
3616     {
3617       /* Clean out any memory we had of the old declaration.  */
3618       tree oldstatic = value_member (olddecl, static_aggregates);
3619       if (oldstatic)
3620         TREE_VALUE (oldstatic) = error_mark_node;
3621
3622       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3623       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3624       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3625       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3626     }
3627
3628   /* Merge the storage class information.  */
3629   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3630   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3631   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3632   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3633   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3634   if (! DECL_EXTERNAL (olddecl))
3635     DECL_EXTERNAL (newdecl) = 0;
3636
3637   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3638     {
3639       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3640       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3641       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3642       DECL_TEMPLATE_INSTANTIATED (newdecl)
3643         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3644       /* Don't really know how much of the language-specific
3645          values we should copy from old to new.  */
3646       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3647       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3648       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3649       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3650       olddecl_friend = DECL_FRIEND_P (olddecl);
3651
3652       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3653       if (TREE_CODE (newdecl) == FUNCTION_DECL
3654           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3655         DECL_BEFRIENDING_CLASSES (newdecl)
3656           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3657                      DECL_BEFRIENDING_CLASSES (olddecl));
3658     }
3659
3660   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3661     {
3662       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3663           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3664         {
3665           /* If newdecl is not a specialization, then it is not a
3666              template-related function at all.  And that means that we
3667              shoud have exited above, returning 0.  */
3668           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3669                               0);
3670
3671           if (TREE_USED (olddecl))
3672             /* From [temp.expl.spec]:
3673
3674                If a template, a member template or the member of a class
3675                template is explicitly specialized then that
3676                specialization shall be declared before the first use of
3677                that specialization that would cause an implicit
3678                instantiation to take place, in every translation unit in
3679                which such a use occurs.  */
3680             cp_error ("explicit specialization of %D after first use",
3681                       olddecl);
3682
3683           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3684         }
3685       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3686
3687       /* If either decl says `inline', this fn is inline, unless its
3688          definition was passed already.  */
3689       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3690         DECL_INLINE (olddecl) = 1;
3691       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3692
3693       if (! types_match)
3694         {
3695           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3696           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3697           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3698         }
3699       if (! types_match || new_defines_function)
3700         {
3701           /* These need to be copied so that the names are available.
3702              Note that if the types do match, we'll preserve inline
3703              info and other bits, but if not, we won't.  */
3704           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3705           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3706         }
3707       if (new_defines_function)
3708         /* If defining a function declared with other language
3709            linkage, use the previously declared language linkage.  */
3710         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3711       else if (types_match)
3712         {
3713           /* If redeclaring a builtin function, and not a definition,
3714              it stays built in.  */
3715           if (DECL_BUILT_IN (olddecl))
3716             {
3717               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3718               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3719               /* If we're keeping the built-in definition, keep the rtl,
3720                  regardless of declaration matches.  */
3721               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3722             }
3723           else
3724             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3725
3726           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3727           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3728             /* Previously saved insns go together with
3729                the function's previous definition.  */
3730             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3731           /* Don't clear out the arguments if we're redefining a function.  */
3732           if (DECL_ARGUMENTS (olddecl))
3733             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3734         }
3735     }
3736
3737   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3738     {
3739       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3740     }
3741
3742   /* Now preserve various other info from the definition.  */
3743   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3744   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3745   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3746   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3747
3748   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3749     {
3750       int function_size;
3751
3752       function_size = sizeof (struct tree_decl);
3753
3754       bcopy ((char *) newdecl + sizeof (struct tree_common),
3755              (char *) olddecl + sizeof (struct tree_common),
3756              function_size - sizeof (struct tree_common));
3757
3758       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3759         {
3760           /* If newdecl is a template instantiation, it is possible that
3761              the following sequence of events has occurred:
3762
3763              o A friend function was declared in a class template.  The
3764              class template was instantiated.
3765
3766              o The instantiation of the friend declaration was
3767              recorded on the instantiation list, and is newdecl.
3768
3769              o Later, however, instantiate_class_template called pushdecl
3770              on the newdecl to perform name injection.  But, pushdecl in
3771              turn called duplicate_decls when it discovered that another
3772              declaration of a global function with the same name already
3773              existed.
3774
3775              o Here, in duplicate_decls, we decided to clobber newdecl.
3776
3777              If we're going to do that, we'd better make sure that
3778              olddecl, and not newdecl, is on the list of
3779              instantiations so that if we try to do the instantiation
3780              again we won't get the clobbered declaration.  */
3781
3782           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3783           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3784
3785           for (; decls; decls = TREE_CHAIN (decls))
3786             if (TREE_VALUE (decls) == newdecl)
3787               TREE_VALUE (decls) = olddecl;
3788         }
3789     }
3790   else
3791     {
3792       bcopy ((char *) newdecl + sizeof (struct tree_common),
3793              (char *) olddecl + sizeof (struct tree_common),
3794              sizeof (struct tree_decl) - sizeof (struct tree_common)
3795              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3796     }
3797
3798   DECL_UID (olddecl) = olddecl_uid;
3799   if (olddecl_friend)
3800     DECL_FRIEND_P (olddecl) = 1;
3801
3802   /* NEWDECL contains the merged attribute lists.
3803      Update OLDDECL to be the same.  */
3804   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3805
3806   return 1;
3807 }
3808
3809 /* Record a decl-node X as belonging to the current lexical scope.
3810    Check for errors (such as an incompatible declaration for the same
3811    name already seen in the same scope).
3812
3813    Returns either X or an old decl for the same name.
3814    If an old decl is returned, it may have been smashed
3815    to agree with what X says.  */
3816
3817 tree
3818 pushdecl (x)
3819      tree x;
3820 {
3821   register tree t;
3822   register tree name;
3823   int need_new_binding;
3824
3825   /* We shouldn't be calling pushdecl when we're generating RTL for a
3826      function that we already did semantic analysis on previously.  */
3827   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3828                       19990913);
3829
3830   need_new_binding = 1;
3831
3832   if (DECL_TEMPLATE_PARM_P (x))
3833     /* Template parameters have no context; they are not X::T even
3834        when declared within a class or namespace.  */
3835     ;
3836   else
3837     {
3838       if (current_function_decl && x != current_function_decl
3839           /* A local declaration for a function doesn't constitute
3840              nesting.  */
3841           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3842           /* A local declaration for an `extern' variable is in the
3843              scoped of the current namespace, not the current
3844              function.  */
3845           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3846           && !DECL_CONTEXT (x))
3847         DECL_CONTEXT (x) = current_function_decl;
3848
3849       /* If this is the declaration for a namespace-scope function,
3850          but the declaration itself is in a local scope, mark the
3851          declaration.  */
3852       if (TREE_CODE (x) == FUNCTION_DECL
3853           && DECL_NAMESPACE_SCOPE_P (x)
3854           && current_function_decl
3855           && x != current_function_decl)
3856         DECL_LOCAL_FUNCTION_P (x) = 1;
3857     }
3858
3859   name = DECL_NAME (x);
3860   if (name)
3861     {
3862 #if 0
3863       /* Not needed...see below.  */
3864       char *file;
3865       int line;
3866 #endif
3867       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3868         name = TREE_OPERAND (name, 0);
3869
3870       /* Namespace-scoped variables are not found in the current level. */
3871       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3872         t = namespace_binding (name, DECL_CONTEXT (x));
3873       else
3874         t = lookup_name_current_level (name);
3875
3876       /* If we are declaring a function, and the result of name-lookup
3877          was an OVERLOAD, look for an overloaded instance that is
3878          actually the same as the function we are declaring.  (If
3879          there is one, we have to merge our declaration with the
3880          previous declaration.)  */
3881       if (t && TREE_CODE (t) == OVERLOAD)
3882         {
3883           tree match;
3884
3885           if (TREE_CODE (x) == FUNCTION_DECL)
3886             for (match = t; match; match = OVL_NEXT (match))
3887               {
3888                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3889                     == DECL_ASSEMBLER_NAME (x))
3890                   break;
3891               }
3892           else
3893             /* Just choose one.  */
3894             match = t;
3895
3896           if (match)
3897             t = OVL_CURRENT (match);
3898           else
3899             t = NULL_TREE;
3900         }
3901
3902       if (t == error_mark_node)
3903         {
3904           /* error_mark_node is 0 for a while during initialization!  */
3905           t = NULL_TREE;
3906           cp_error_at ("`%#D' used prior to declaration", x);
3907         }
3908       else if (t != NULL_TREE)
3909         {
3910           if (TREE_CODE (t) == PARM_DECL)
3911             {
3912               if (DECL_CONTEXT (t) == NULL_TREE)
3913                 fatal ("parse errors have confused me too much");
3914
3915               /* Check for duplicate params.  */
3916               if (duplicate_decls (x, t))
3917                 return t;
3918             }
3919           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3920                     || DECL_FUNCTION_TEMPLATE_P (x))
3921                    && is_overloaded_fn (t))
3922             /* Don't do anything just yet. */;
3923           else if (t == wchar_decl_node)
3924             {
3925               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3926                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3927
3928               /* Throw away the redeclaration.  */
3929               return t;
3930             }
3931           else if (TREE_CODE (t) != TREE_CODE (x))
3932             {
3933               if (duplicate_decls (x, t))
3934                 return t;
3935             }
3936           else if (duplicate_decls (x, t))
3937             {
3938               if (TREE_CODE (t) == TYPE_DECL)
3939                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3940               else if (TREE_CODE (t) == FUNCTION_DECL)
3941                 check_default_args (t);
3942
3943               return t;
3944             }
3945           else if (DECL_MAIN_P (x))
3946             {
3947               /* A redeclaration of main, but not a duplicate of the
3948                  previous one.
3949
3950                  [basic.start.main]
3951
3952                  This function shall not be overloaded.  */
3953               cp_error_at ("invalid redeclaration of `%D'", t);
3954               cp_error ("as `%D'", x);
3955               /* We don't try to push this declaration since that
3956                  causes a crash.  */
3957               return x;
3958             }
3959         }
3960
3961       check_template_shadow (x);
3962
3963       /* If this is a function conjured up by the backend, massage it
3964          so it looks friendly.  */
3965       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3966         {
3967           retrofit_lang_decl (x);
3968           DECL_LANGUAGE (x) = lang_c;
3969         }
3970
3971       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3972         {
3973           t = push_overloaded_decl (x, PUSH_LOCAL);
3974           if (t != x)
3975             return t;
3976           if (!namespace_bindings_p ())
3977             /* We do not need to create a binding for this name;
3978                push_overloaded_decl will have already done so if
3979                necessary.  */
3980             need_new_binding = 0;
3981         }
3982       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3983         {
3984           t = push_overloaded_decl (x, PUSH_GLOBAL);
3985           if (t == x)
3986             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3987           return t;
3988         }
3989
3990       /* If declaring a type as a typedef, copy the type (unless we're
3991          at line 0), and install this TYPE_DECL as the new type's typedef
3992          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3993       if (TREE_CODE (x) == TYPE_DECL)
3994         {
3995           tree type = TREE_TYPE (x);
3996           if (DECL_SOURCE_LINE (x) == 0)
3997             {
3998               if (TYPE_NAME (type) == 0)
3999                 TYPE_NAME (type) = x;
4000             }
4001           else if (type != error_mark_node && TYPE_NAME (type) != x
4002                    /* We don't want to copy the type when all we're
4003                       doing is making a TYPE_DECL for the purposes of
4004                       inlining.  */
4005                    && (!TYPE_NAME (type)
4006                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4007             {
4008               DECL_ORIGINAL_TYPE (x) = type;
4009               type = build_type_copy (type);
4010               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4011               TYPE_NAME (type) = x;
4012               TREE_TYPE (x) = type;
4013             }
4014
4015           if (type != error_mark_node
4016               && TYPE_NAME (type)
4017               && TYPE_IDENTIFIER (type))
4018             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4019                                                   current_binding_level);
4020
4021         }
4022
4023       /* Multiple external decls of the same identifier ought to match.
4024
4025          We get warnings about inline functions where they are defined.
4026          We get warnings about other functions from push_overloaded_decl.
4027
4028          Avoid duplicate warnings where they are used.  */
4029       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4030         {
4031           tree decl;
4032
4033           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4034           if (decl && TREE_CODE (decl) == OVERLOAD)
4035             decl = OVL_FUNCTION (decl);
4036
4037           if (decl && decl != error_mark_node
4038               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4039               /* If different sort of thing, we already gave an error.  */
4040               && TREE_CODE (decl) == TREE_CODE (x)
4041               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4042             {
4043               cp_pedwarn ("type mismatch with previous external decl", x);
4044               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4045             }
4046         }
4047
4048       /* This name is new in its binding level.
4049          Install the new declaration and return it.  */
4050       if (namespace_bindings_p ())
4051         {
4052           /* Install a global value.  */
4053
4054           /* If the first global decl has external linkage,
4055              warn if we later see static one.  */
4056           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4057             TREE_PUBLIC (name) = 1;
4058
4059           /* Bind the mangled name for the entity.  In the future, we
4060              should not need to do this; mangled names are an
4061              implementation detail of which the front-end should not
4062              need to be aware.  */
4063           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4064                 && t != NULL_TREE)
4065               /* For an ordinary function, we create a binding from
4066                  the mangled name (i.e., NAME) to the DECL.  But, for
4067                  an `extern "C"' function, the mangled name and the
4068                  ordinary name are the same so we need not do this.  */
4069               && !DECL_EXTERN_C_FUNCTION_P (x))
4070             {
4071               tree mangled_name;
4072
4073               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4074                   || TREE_CODE (x) == NAMESPACE_DECL)
4075                 mangled_name = name;
4076               else
4077                 mangled_name = DECL_ASSEMBLER_NAME (x);
4078
4079               if (TREE_CODE (x) == FUNCTION_DECL)
4080                 my_friendly_assert
4081                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4082                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4083               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4084             }
4085
4086           /* Don't forget if the function was used via an implicit decl.  */
4087           if (IDENTIFIER_IMPLICIT_DECL (name)
4088               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4089             TREE_USED (x) = 1;
4090
4091           /* Don't forget if its address was taken in that way.  */
4092           if (IDENTIFIER_IMPLICIT_DECL (name)
4093               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4094             TREE_ADDRESSABLE (x) = 1;
4095
4096           /* Warn about mismatches against previous implicit decl.  */
4097           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4098               /* If this real decl matches the implicit, don't complain.  */
4099               && ! (TREE_CODE (x) == FUNCTION_DECL
4100                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4101             cp_warning
4102               ("`%D' was previously implicitly declared to return `int'", x);
4103
4104           /* If new decl is `static' and an `extern' was seen previously,
4105              warn about it.  */
4106           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4107             warn_extern_redeclared_static (x, t);
4108         }
4109       else
4110         {
4111           /* Here to install a non-global value.  */
4112           tree oldlocal = IDENTIFIER_VALUE (name);
4113           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4114
4115           if (need_new_binding)
4116             {
4117               push_local_binding (name, x, 0);
4118               /* Because push_local_binding will hook X on to the
4119                  current_binding_level's name list, we don't want to
4120                  do that again below.  */
4121               need_new_binding = 0;
4122             }
4123
4124           /* If this is a TYPE_DECL, push it into the type value slot.  */
4125           if (TREE_CODE (x) == TYPE_DECL)
4126             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4127                                                   current_binding_level);
4128
4129           /* Clear out any TYPE_DECL shadowed by a namespace so that
4130              we won't think this is a type.  The C struct hack doesn't
4131              go through namespaces.  */
4132           if (TREE_CODE (x) == NAMESPACE_DECL)
4133             set_identifier_type_value_with_scope (name, NULL_TREE,
4134                                                   current_binding_level);
4135
4136           if (oldlocal)
4137             {
4138               tree d = oldlocal;
4139
4140               while (oldlocal
4141                      && TREE_CODE (oldlocal) == VAR_DECL
4142                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4143                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4144
4145               if (oldlocal == NULL_TREE)
4146                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4147             }
4148
4149           /* If this is an extern function declaration, see if we
4150              have a global definition or declaration for the function.  */
4151           if (oldlocal == NULL_TREE
4152               && DECL_EXTERNAL (x)
4153               && oldglobal != NULL_TREE
4154               && TREE_CODE (x) == FUNCTION_DECL
4155               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4156             {
4157               /* We have one.  Their types must agree.  */
4158               if (decls_match (x, oldglobal))
4159                 /* OK */;
4160               else
4161                 {
4162                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4163                   cp_warning_at ("global declaration `%#D'", oldglobal);
4164                 }
4165             }
4166           /* If we have a local external declaration,
4167              and no file-scope declaration has yet been seen,
4168              then if we later have a file-scope decl it must not be static.  */
4169           if (oldlocal == NULL_TREE
4170               && oldglobal == NULL_TREE
4171               && DECL_EXTERNAL (x)
4172               && TREE_PUBLIC (x))
4173             TREE_PUBLIC (name) = 1;
4174
4175           /* Warn if shadowing an argument at the top level of the body.  */
4176           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4177               /* Inline decls shadow nothing.  */
4178               && !DECL_FROM_INLINE (x)
4179               && TREE_CODE (oldlocal) == PARM_DECL
4180               /* Don't complain if it's from an enclosing function.  */
4181               && DECL_CONTEXT (oldlocal) == current_function_decl
4182               && TREE_CODE (x) != PARM_DECL)
4183             {
4184               /* Go to where the parms should be and see if we
4185                  find them there.  */
4186               struct binding_level *b = current_binding_level->level_chain;
4187
4188               if (cleanup_label)
4189                 b = b->level_chain;
4190
4191               /* ARM $8.3 */
4192               if (b->parm_flag == 1)
4193                 cp_error ("declaration of `%#D' shadows a parameter", name);
4194             }
4195
4196           /* Maybe warn if shadowing something else.  */
4197           if (warn_shadow && !DECL_EXTERNAL (x)
4198               /* Inline decls shadow nothing.  */
4199               && !DECL_FROM_INLINE (x)
4200               /* No shadow warnings for internally generated vars.  */
4201               && ! DECL_ARTIFICIAL (x)
4202               /* No shadow warnings for vars made for inlining.  */
4203               && ! DECL_FROM_INLINE (x))
4204             {
4205               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4206                 warning ("declaration of `%s' shadows a parameter",
4207                         IDENTIFIER_POINTER (name));
4208               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4209                        && current_class_ptr
4210                        && !TREE_STATIC (name))
4211                 warning ("declaration of `%s' shadows a member of `this'",
4212                         IDENTIFIER_POINTER (name));
4213               else if (oldlocal != NULL_TREE)
4214                 warning ("declaration of `%s' shadows previous local",
4215                         IDENTIFIER_POINTER (name));
4216               else if (oldglobal != NULL_TREE)
4217                 /* XXX shadow warnings in outer-more namespaces */
4218                 warning ("declaration of `%s' shadows global declaration",
4219                         IDENTIFIER_POINTER (name));
4220             }
4221         }
4222
4223       if (TREE_CODE (x) == FUNCTION_DECL)
4224         check_default_args (x);
4225
4226       /* Keep count of variables in this level with incomplete type.  */
4227       if (TREE_CODE (x) == VAR_DECL
4228           && TREE_TYPE (x) != error_mark_node
4229           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4230                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4231               /* RTTI TD entries are created while defining the type_info.  */
4232               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4233                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4234         {
4235           if (namespace_bindings_p ())
4236             namespace_scope_incomplete
4237               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4238           else
4239             current_binding_level->incomplete
4240               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4241         }
4242     }
4243
4244   if (need_new_binding)
4245     add_decl_to_level (x,
4246                        DECL_NAMESPACE_SCOPE_P (x)
4247                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4248                        : current_binding_level);
4249
4250   return x;
4251 }
4252
4253 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4254    caller to set DECL_CONTEXT properly.  */
4255
4256 static tree
4257 pushdecl_with_scope (x, level)
4258      tree x;
4259      struct binding_level *level;
4260 {
4261   register struct binding_level *b;
4262   tree function_decl = current_function_decl;
4263
4264   current_function_decl = NULL_TREE;
4265   if (level->parm_flag == 2)
4266     {
4267       b = class_binding_level;
4268       class_binding_level = level;
4269       pushdecl_class_level (x);
4270       class_binding_level = b;
4271     }
4272   else
4273     {
4274       b = current_binding_level;
4275       current_binding_level = level;
4276       x = pushdecl (x);
4277       current_binding_level = b;
4278     }
4279   current_function_decl = function_decl;
4280   return x;
4281 }
4282
4283 /* Like pushdecl, only it places X in the current namespace,
4284    if appropriate.  */
4285
4286 tree
4287 pushdecl_namespace_level (x)
4288      tree x;
4289 {
4290   register struct binding_level *b = current_binding_level;
4291   register tree t;
4292
4293   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4294
4295   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4296      what we want.  */
4297   if (TREE_CODE (x) == TYPE_DECL)
4298     {
4299       tree name = DECL_NAME (x);
4300       tree newval;
4301       tree *ptr = (tree *)0;
4302       for (; b != global_binding_level; b = b->level_chain)
4303         {
4304           tree shadowed = b->type_shadowed;
4305           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4306             if (TREE_PURPOSE (shadowed) == name)
4307               {
4308                 ptr = &TREE_VALUE (shadowed);
4309                 /* Can't break out of the loop here because sometimes
4310                    a binding level will have duplicate bindings for
4311                    PT names.  It's gross, but I haven't time to fix it.  */
4312               }
4313         }
4314       newval = TREE_TYPE (x);
4315       if (ptr == (tree *)0)
4316         {
4317           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4318              up here if this is changed to an assertion.  --KR  */
4319           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4320         }
4321       else
4322         {
4323           *ptr = newval;
4324         }
4325     }
4326   return t;
4327 }
4328
4329 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4330    if appropriate.  */
4331
4332 tree
4333 pushdecl_top_level (x)
4334      tree x;
4335 {
4336   push_to_top_level ();
4337   x = pushdecl_namespace_level (x);
4338   pop_from_top_level ();
4339   return x;
4340 }
4341
4342 /* Make the declaration of X appear in CLASS scope.  */
4343
4344 void
4345 pushdecl_class_level (x)
4346      tree x;
4347 {
4348   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4349      scope looks for the pre-mangled name.  */
4350   register tree name;
4351
4352   if (TREE_CODE (x) == OVERLOAD)
4353     x = OVL_CURRENT (x);
4354   name = DECL_NAME (x);
4355
4356   if (name)
4357     {
4358       push_class_level_binding (name, x);
4359       if (TREE_CODE (x) == TYPE_DECL)
4360         set_identifier_type_value (name, TREE_TYPE (x));
4361     }
4362   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4363     {
4364       tree f;
4365
4366       for (f = TYPE_FIELDS (TREE_TYPE (x));
4367            f;
4368            f = TREE_CHAIN (f))
4369         pushdecl_class_level (f);
4370     }
4371 }
4372
4373 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4374    DECL, or a modified version thereof.  */
4375
4376 tree
4377 maybe_push_decl (decl)
4378      tree decl;
4379 {
4380   tree type = TREE_TYPE (decl);
4381
4382   /* Add this decl to the current binding level, but not if it comes
4383      from another scope, e.g. a static member variable.  TEM may equal
4384      DECL or it may be a previous decl of the same name.  */
4385   if (decl == error_mark_node
4386       || (TREE_CODE (decl) != PARM_DECL
4387           && DECL_CONTEXT (decl) != NULL_TREE
4388           /* Definitions of namespace members outside their namespace are
4389              possible. */
4390           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4391       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4392       || TREE_CODE (type) == UNKNOWN_TYPE
4393       /* The declaration of a template specialization does not affect
4394          the functions available for overload resolution, so we do not
4395          call pushdecl.  */
4396       || (TREE_CODE (decl) == FUNCTION_DECL
4397           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4398     return decl;
4399   else
4400     return pushdecl (decl);
4401 }
4402
4403 /* Make the declaration(s) of X appear in CLASS scope
4404    under the name NAME.  */
4405
4406 void
4407 push_class_level_binding (name, x)
4408      tree name;
4409      tree x;
4410 {
4411   tree binding;
4412   /* The class_binding_level will be NULL if x is a template
4413      parameter name in a member template.  */
4414   if (!class_binding_level)
4415     return;
4416
4417   /* Make sure that this new member does not have the same name
4418      as a template parameter.  */
4419   if (TYPE_BEING_DEFINED (current_class_type))
4420     check_template_shadow (x);
4421
4422   /* If this declaration shadows a declaration from an enclosing
4423      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4424      we leave this class.  Record the shadowed declaration here.  */
4425   binding = IDENTIFIER_BINDING (name);
4426   if (binding
4427       && ((TREE_CODE (x) == OVERLOAD
4428            && BINDING_VALUE (binding)
4429            && is_overloaded_fn (BINDING_VALUE (binding)))
4430           || INHERITED_VALUE_BINDING_P (binding)))
4431     {
4432       tree shadow;
4433       tree old_decl;
4434
4435       /* If the old binding was from a base class, and was for a tag
4436          name, slide it over to make room for the new binding.  The
4437          old binding is still visible if explicitly qualified with a
4438          class-key.  */
4439       if (INHERITED_VALUE_BINDING_P (binding)
4440           && BINDING_VALUE (binding)
4441           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4442           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4443           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4444         {
4445           old_decl = BINDING_TYPE (binding);
4446           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4447           BINDING_VALUE (binding) = NULL_TREE;
4448           INHERITED_VALUE_BINDING_P (binding) = 0;
4449         }
4450       else
4451         old_decl = BINDING_VALUE (binding);
4452
4453       /* There was already a binding for X containing fewer
4454          functions than are named in X.  Find the previous
4455          declaration of X on the class-shadowed list, and update it.  */
4456       for (shadow = class_binding_level->class_shadowed;
4457            shadow;
4458            shadow = TREE_CHAIN (shadow))
4459         if (TREE_PURPOSE (shadow) == name
4460             && TREE_TYPE (shadow) == old_decl)
4461           {
4462             BINDING_VALUE (binding) = x;
4463             INHERITED_VALUE_BINDING_P (binding) = 0;
4464             TREE_TYPE (shadow) = x;
4465             return;
4466           }
4467     }
4468
4469   /* If we didn't replace an existing binding, put the binding on the
4470      stack of bindings for the identifier, and update
4471      IDENTIFIER_CLASS_VALUE.  */
4472   if (push_class_binding (name, x))
4473     {
4474       class_binding_level->class_shadowed
4475         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4476                      class_binding_level->class_shadowed);
4477       /* Record the value we are binding NAME to so that we can know
4478          what to pop later.  */
4479       TREE_TYPE (class_binding_level->class_shadowed) = x;
4480     }
4481 }
4482
4483 /* Insert another USING_DECL into the current binding level, returning
4484    this declaration. If this is a redeclaration, do nothing, and
4485    return NULL_TREE if this not in namespace scope (in namespace
4486    scope, a using decl might extend any previous bindings).  */
4487
4488 tree
4489 push_using_decl (scope, name)
4490      tree scope;
4491      tree name;
4492 {
4493   tree decl;
4494
4495   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4496   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4497   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4498     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4499       break;
4500   if (decl)
4501     return namespace_bindings_p () ? decl : NULL_TREE;
4502   decl = build_lang_decl (USING_DECL, name, void_type_node);
4503   DECL_INITIAL (decl) = scope;
4504   TREE_CHAIN (decl) = current_binding_level->usings;
4505   current_binding_level->usings = decl;
4506   return decl;
4507 }
4508
4509 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4510    changed (i.e. there was already a directive), or the fresh
4511    TREE_LIST otherwise.  */
4512
4513 tree
4514 push_using_directive (used)
4515      tree used;
4516 {
4517   tree ud = current_binding_level->using_directives;
4518   tree iter, ancestor;
4519
4520   /* Check if we already have this. */
4521   if (purpose_member (used, ud) != NULL_TREE)
4522     return NULL_TREE;
4523
4524   /* Recursively add all namespaces used. */
4525   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4526     push_using_directive (TREE_PURPOSE (iter));
4527
4528   ancestor = namespace_ancestor (current_decl_namespace (), used);
4529   ud = current_binding_level->using_directives;
4530   ud = tree_cons (used, ancestor, ud);
4531   current_binding_level->using_directives = ud;
4532   return ud;
4533 }
4534
4535 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4536    other definitions already in place.  We get around this by making
4537    the value of the identifier point to a list of all the things that
4538    want to be referenced by that name.  It is then up to the users of
4539    that name to decide what to do with that list.
4540
4541    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4542    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4543
4544    FLAGS is a bitwise-or of the following values:
4545      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4546                  namespace scope.
4547      PUSH_USING: DECL is being pushed as the result of a using
4548                  declaration.
4549
4550    The value returned may be a previous declaration if we guessed wrong
4551    about what language DECL should belong to (C or C++).  Otherwise,
4552    it's always DECL (and never something that's not a _DECL).  */
4553
4554 tree
4555 push_overloaded_decl (decl, flags)
4556      tree decl;
4557      int flags;
4558 {
4559   tree name = DECL_NAME (decl);
4560   tree old;
4561   tree new_binding;
4562   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4563
4564   if (doing_global)
4565     old = namespace_binding (name, DECL_CONTEXT (decl));
4566   else
4567     old = lookup_name_current_level (name);
4568
4569   if (old)
4570     {
4571       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4572         {
4573           tree t = TREE_TYPE (old);
4574           if (IS_AGGR_TYPE (t) && warn_shadow
4575               && (! DECL_IN_SYSTEM_HEADER (decl)
4576                   || ! DECL_IN_SYSTEM_HEADER (old)))
4577             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4578           old = NULL_TREE;
4579         }
4580       else if (is_overloaded_fn (old))
4581         {
4582           tree tmp;
4583
4584           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4585             {
4586               tree fn = OVL_CURRENT (tmp);
4587
4588               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4589                   && !(flags & PUSH_USING)
4590                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4591                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4592                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4593                           decl, fn);
4594
4595               if (duplicate_decls (decl, fn))
4596                 return fn;
4597             }
4598         }
4599       else if (old == error_mark_node)
4600         /* Ignore the undefined symbol marker.  */
4601         old = NULL_TREE;
4602       else
4603         {
4604           cp_error_at ("previous non-function declaration `%#D'", old);
4605           cp_error ("conflicts with function declaration `%#D'", decl);
4606           return decl;
4607         }
4608     }
4609
4610   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4611     {
4612       if (old && TREE_CODE (old) != OVERLOAD)
4613         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4614       else
4615         new_binding = ovl_cons (decl, old);
4616       if (flags & PUSH_USING)
4617         OVL_USED (new_binding) = 1;
4618     }
4619   else
4620     /* NAME is not ambiguous.  */
4621     new_binding = decl;
4622
4623   if (doing_global)
4624     set_namespace_binding (name, current_namespace, new_binding);
4625   else
4626     {
4627       /* We only create an OVERLOAD if there was a previous binding at
4628          this level, or if decl is a template. In the former case, we
4629          need to remove the old binding and replace it with the new
4630          binding.  We must also run through the NAMES on the binding
4631          level where the name was bound to update the chain.  */
4632
4633       if (TREE_CODE (new_binding) == OVERLOAD && old)
4634         {
4635           tree *d;
4636
4637           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4638                *d;
4639                d = &TREE_CHAIN (*d))
4640             if (*d == old
4641                 || (TREE_CODE (*d) == TREE_LIST
4642                     && TREE_VALUE (*d) == old))
4643               {
4644                 if (TREE_CODE (*d) == TREE_LIST)
4645                   /* Just replace the old binding with the new.  */
4646                   TREE_VALUE (*d) = new_binding;
4647                 else
4648                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4649                   *d = tree_cons (NULL_TREE, new_binding,
4650                                   TREE_CHAIN (*d));
4651
4652                 /* And update the CPLUS_BINDING node.  */
4653                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4654                   = new_binding;
4655                 return decl;
4656               }
4657
4658           /* We should always find a previous binding in this case.  */
4659           my_friendly_abort (0);
4660         }
4661
4662       /* Install the new binding.  */
4663       push_local_binding (name, new_binding, flags);
4664     }
4665
4666   return decl;
4667 }
4668 \f
4669 /* Generate an implicit declaration for identifier FUNCTIONID
4670    as a function of type int ().  Print a warning if appropriate.  */
4671
4672 tree
4673 implicitly_declare (functionid)
4674      tree functionid;
4675 {
4676   register tree decl;
4677
4678   /* We used to reuse an old implicit decl here,
4679      but this loses with inline functions because it can clobber
4680      the saved decl chains.  */
4681   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4682
4683   DECL_EXTERNAL (decl) = 1;
4684   TREE_PUBLIC (decl) = 1;
4685
4686   /* ISO standard says implicit declarations are in the innermost block.
4687      So we record the decl in the standard fashion.  */
4688   pushdecl (decl);
4689   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4690
4691   if (warn_implicit
4692       /* Only one warning per identifier.  */
4693       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4694     {
4695       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4696     }
4697
4698   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4699
4700   return decl;
4701 }
4702
4703 /* Return zero if the declaration NEWDECL is valid
4704    when the declaration OLDDECL (assumed to be for the same name)
4705    has already been seen.
4706    Otherwise return an error message format string with a %s
4707    where the identifier should go.  */
4708
4709 static const char *
4710 redeclaration_error_message (newdecl, olddecl)
4711      tree newdecl, olddecl;
4712 {
4713   if (TREE_CODE (newdecl) == TYPE_DECL)
4714     {
4715       /* Because C++ can put things into name space for free,
4716          constructs like "typedef struct foo { ... } foo"
4717          would look like an erroneous redeclaration.  */
4718       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4719         return 0;
4720       else
4721         return "redefinition of `%#D'";
4722     }
4723   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4724     {
4725       /* If this is a pure function, its olddecl will actually be
4726          the original initialization to `0' (which we force to call
4727          abort()).  Don't complain about redefinition in this case.  */
4728       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4729         return 0;
4730
4731       /* If both functions come from different namespaces, this is not
4732          a redeclaration - this is a conflict with a used function. */
4733       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4734           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4735         return "`%D' conflicts with used function";
4736
4737       /* We'll complain about linkage mismatches in
4738          warn_extern_redeclared_static.  */
4739
4740       /* Defining the same name twice is no good.  */
4741       if (DECL_INITIAL (olddecl) != NULL_TREE
4742           && DECL_INITIAL (newdecl) != NULL_TREE)
4743         {
4744           if (DECL_NAME (olddecl) == NULL_TREE)
4745             return "`%#D' not declared in class";
4746           else
4747             return "redefinition of `%#D'";
4748         }
4749       return 0;
4750     }
4751   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4752     {
4753       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4754            && (DECL_TEMPLATE_RESULT (newdecl)
4755                != DECL_TEMPLATE_RESULT (olddecl))
4756            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4757            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4758           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4759               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4760               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4761         return "redefinition of `%#D'";
4762       return 0;
4763     }
4764   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4765     {
4766       /* Objects declared at top level:  */
4767       /* If at least one is a reference, it's ok.  */
4768       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4769         return 0;
4770       /* Reject two definitions.  */
4771       return "redefinition of `%#D'";
4772     }
4773   else
4774     {
4775       /* Objects declared with block scope:  */
4776       /* Reject two definitions, and reject a definition
4777          together with an external reference.  */
4778       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4779         return "redeclaration of `%#D'";
4780       return 0;
4781     }
4782 }
4783 \f
4784 /* Create a new label, named ID.  */
4785
4786 static tree
4787 make_label_decl (id, local_p)
4788      tree id;
4789      int local_p;
4790 {
4791   tree decl;
4792
4793   decl = build_decl (LABEL_DECL, id, void_type_node);
4794   if (expanding_p)
4795     /* Make sure every label has an rtx.  */
4796     label_rtx (decl);
4797
4798   DECL_CONTEXT (decl) = current_function_decl;
4799   DECL_MODE (decl) = VOIDmode;
4800   C_DECLARED_LABEL_FLAG (decl) = local_p;
4801
4802   /* Say where one reference is to the label, for the sake of the
4803      error if it is not defined.  */
4804   DECL_SOURCE_LINE (decl) = lineno;
4805   DECL_SOURCE_FILE (decl) = input_filename;
4806
4807   /* Record the fact that this identifier is bound to this label.  */
4808   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4809
4810   return decl;
4811 }
4812
4813 /* Record this label on the list of used labels so that we can check
4814    at the end of the function to see whether or not the label was
4815    actually defined, and so we can check when the label is defined whether
4816    this use is valid.  */
4817
4818 static void
4819 use_label (decl)
4820      tree decl;
4821 {
4822   if (named_label_uses == NULL
4823       || named_label_uses->names_in_scope != current_binding_level->names
4824       || named_label_uses->label_decl != decl)
4825     {
4826       struct named_label_use_list *new_ent;
4827       new_ent = ((struct named_label_use_list *)
4828                  ggc_alloc (sizeof (struct named_label_use_list)));
4829       new_ent->label_decl = decl;
4830       new_ent->names_in_scope = current_binding_level->names;
4831       new_ent->binding_level = current_binding_level;
4832       new_ent->lineno_o_goto = lineno;
4833       new_ent->filename_o_goto = input_filename;
4834       new_ent->next = named_label_uses;
4835       named_label_uses = new_ent;
4836     }
4837 }
4838
4839 /* Look for a label named ID in the current function.  If one cannot
4840    be found, create one.  (We keep track of used, but undefined,
4841    labels, and complain about them at the end of a function.)  */
4842
4843 tree
4844 lookup_label (id)
4845      tree id;
4846 {
4847   tree decl;
4848   struct named_label_list *ent;
4849
4850   /* You can't use labels at global scope.  */
4851   if (current_function_decl == NULL_TREE)
4852     {
4853       error ("label `%s' referenced outside of any function",
4854              IDENTIFIER_POINTER (id));
4855       return NULL_TREE;
4856     }
4857
4858   /* See if we've already got this label.  */
4859   decl = IDENTIFIER_LABEL_VALUE (id);
4860   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4861     return decl;
4862
4863   /* Record this label on the list of labels used in this function.
4864      We do this before calling make_label_decl so that we get the
4865      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4866   ent = ((struct named_label_list *)
4867          ggc_alloc_cleared (sizeof (struct named_label_list)));
4868   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4869   ent->next = named_labels;
4870   named_labels = ent;
4871
4872   /* We need a new label.  */
4873   decl = make_label_decl (id, /*local_p=*/0);
4874
4875   /* Now fill in the information we didn't have before.  */
4876   ent->label_decl = decl;
4877
4878   return decl;
4879 }
4880
4881 /* Declare a local label named ID.  */
4882
4883 tree
4884 declare_local_label (id)
4885      tree id;
4886 {
4887   tree decl;
4888
4889   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4890      this scope we can restore the old value of
4891      IDENTIFIER_TYPE_VALUE.  */
4892   current_binding_level->shadowed_labels
4893     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4894                  current_binding_level->shadowed_labels);
4895   /* Look for the label.  */
4896   decl = make_label_decl (id, /*local_p=*/1);
4897   /* Now fill in the information we didn't have before.  */
4898   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4899
4900   return decl;
4901 }
4902
4903 /* Returns nonzero if it is ill-formed to jump past the declaration of
4904    DECL.  Returns 2 if it's also a real problem.  */
4905
4906 static int
4907 decl_jump_unsafe (decl)
4908      tree decl;
4909 {
4910   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4911     return 0;
4912
4913   if (DECL_INITIAL (decl) == NULL_TREE
4914       && pod_type_p (TREE_TYPE (decl)))
4915     return 0;
4916
4917   /* This is really only important if we're crossing an initialization.
4918      The POD stuff is just pedantry; why should it matter if the class
4919      contains a field of pointer to member type?  */
4920   if (DECL_INITIAL (decl)
4921       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4922     return 2;
4923   return 1;
4924 }
4925
4926 /* Check that a single previously seen jump to a newly defined label
4927    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4928    the jump context; NAMES are the names in scope in LEVEL at the jump
4929    context; FILE and LINE are the source position of the jump or 0.  */
4930
4931 static void
4932 check_previous_goto_1 (decl, level, names, file, line)
4933      tree decl;
4934      struct binding_level *level;
4935      tree names;
4936      const char *file;
4937      int line;
4938 {
4939   int identified = 0;
4940   int saw_eh = 0;
4941   struct binding_level *b = current_binding_level;
4942   for (; b; b = b->level_chain)
4943     {
4944       tree new_decls = b->names;
4945       tree old_decls = (b == level ? names : NULL_TREE);
4946       for (; new_decls != old_decls;
4947            new_decls = TREE_CHAIN (new_decls))
4948         {
4949           int problem = decl_jump_unsafe (new_decls);
4950           if (! problem)
4951             continue;
4952
4953           if (! identified)
4954             {
4955               if (decl)
4956                 cp_pedwarn ("jump to label `%D'", decl);
4957               else
4958                 pedwarn ("jump to case label");
4959
4960               if (file)
4961                 pedwarn_with_file_and_line (file, line, "  from here");
4962               identified = 1;
4963             }
4964
4965           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4966             /* Can't skip init of __exception_info.  */
4967             cp_error_at ("  enters catch block", new_decls);
4968           else if (problem > 1)
4969             cp_error_at ("  crosses initialization of `%#D'",
4970                          new_decls);
4971           else
4972             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4973                            new_decls);
4974         }
4975
4976       if (b == level)
4977         break;
4978       if (b->eh_region && ! saw_eh)
4979         {
4980           if (! identified)
4981             {
4982               if (decl)
4983                 cp_pedwarn ("jump to label `%D'", decl);
4984               else
4985                 pedwarn ("jump to case label");
4986
4987               if (file)
4988                 pedwarn_with_file_and_line (file, line, "  from here");
4989               identified = 1;
4990             }
4991           error ("  enters try block");
4992           saw_eh = 1;
4993         }
4994     }
4995 }
4996
4997 static void
4998 check_previous_goto (use)
4999      struct named_label_use_list *use;
5000 {
5001   check_previous_goto_1 (use->label_decl, use->binding_level,
5002                          use->names_in_scope, use->filename_o_goto,
5003                          use->lineno_o_goto);
5004 }
5005
5006 static void
5007 check_switch_goto (level)
5008      struct binding_level *level;
5009 {
5010   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5011 }
5012
5013 /* Check that any previously seen jumps to a newly defined label DECL
5014    are OK.  Called by define_label.  */
5015
5016 static void
5017 check_previous_gotos (decl)
5018      tree decl;
5019 {
5020   struct named_label_use_list **usep;
5021
5022   if (! TREE_USED (decl))
5023     return;
5024
5025   for (usep = &named_label_uses; *usep; )
5026     {
5027       struct named_label_use_list *use = *usep;
5028       if (use->label_decl == decl)
5029         {
5030           check_previous_goto (use);
5031           *usep = use->next;
5032         }
5033       else
5034         usep = &(use->next);
5035     }
5036 }
5037
5038 /* Check that a new jump to a label DECL is OK.  Called by
5039    finish_goto_stmt.  */
5040
5041 void
5042 check_goto (decl)
5043      tree decl;
5044 {
5045   int identified = 0;
5046   tree bad;
5047   struct named_label_list *lab;
5048
5049   /* We can't know where a computed goto is jumping.  So we assume
5050      that it's OK.  */
5051   if (! DECL_P (decl))
5052     return;
5053
5054   /* If the label hasn't been defined yet, defer checking.  */
5055   if (! DECL_INITIAL (decl))
5056     {
5057       use_label (decl);
5058       return;
5059     }
5060
5061   for (lab = named_labels; lab; lab = lab->next)
5062     if (decl == lab->label_decl)
5063       break;
5064
5065   /* If the label is not on named_labels it's a gcc local label, so
5066      it must be in an outer scope, so jumping to it is always OK.  */
5067   if (lab == 0)
5068     return;
5069
5070   if ((lab->eh_region || lab->bad_decls) && !identified)
5071     {
5072       cp_pedwarn_at ("jump to label `%D'", decl);
5073       pedwarn ("  from here");
5074       identified = 1;
5075     }
5076
5077   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5078     {
5079       tree b = TREE_VALUE (bad);
5080       int u = decl_jump_unsafe (b);
5081
5082       if (u > 1 && DECL_ARTIFICIAL (b))
5083         /* Can't skip init of __exception_info.  */
5084         cp_error_at ("  enters catch block", b);
5085       else if (u > 1)
5086         cp_error_at ("  skips initialization of `%#D'", b);
5087       else
5088         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5089     }
5090
5091   if (lab->eh_region)
5092     error ("  enters try block");
5093 }
5094
5095 /* Define a label, specifying the location in the source file.
5096    Return the LABEL_DECL node for the label, if the definition is valid.
5097    Otherwise return 0.  */
5098
5099 tree
5100 define_label (filename, line, name)
5101      const char *filename;
5102      int line;
5103      tree name;
5104 {
5105   tree decl = lookup_label (name);
5106   struct named_label_list *ent;
5107
5108   for (ent = named_labels; ent; ent = ent->next)
5109     if (ent->label_decl == decl)
5110       break;
5111
5112   /* After labels, make any new cleanups go into their
5113      own new (temporary) binding contour.  */
5114   current_binding_level->more_cleanups_ok = 0;
5115
5116   if (name == get_identifier ("wchar_t"))
5117     cp_pedwarn ("label named wchar_t");
5118
5119   if (DECL_INITIAL (decl) != NULL_TREE)
5120     {
5121       cp_error ("duplicate label `%D'", decl);
5122       return 0;
5123     }
5124   else
5125     {
5126       /* Mark label as having been defined.  */
5127       DECL_INITIAL (decl) = error_mark_node;
5128       /* Say where in the source.  */
5129       DECL_SOURCE_FILE (decl) = filename;
5130       DECL_SOURCE_LINE (decl) = line;
5131       if (ent)
5132         {
5133           ent->names_in_scope = current_binding_level->names;
5134           ent->binding_level = current_binding_level;
5135         }
5136       check_previous_gotos (decl);
5137       current_function_return_value = NULL_TREE;
5138       return decl;
5139     }
5140 }
5141
5142 struct cp_switch
5143 {
5144   struct binding_level *level;
5145   struct cp_switch *next;
5146 };
5147
5148 static struct cp_switch *switch_stack;
5149
5150 void
5151 push_switch ()
5152 {
5153   struct cp_switch *p
5154     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5155   p->level = current_binding_level;
5156   p->next = switch_stack;
5157   switch_stack = p;
5158 }
5159
5160 void
5161 pop_switch ()
5162 {
5163   struct cp_switch *cs;
5164
5165   cs = switch_stack;
5166   switch_stack = switch_stack->next;
5167   free (cs);
5168 }
5169
5170 /* Note that we've seen a definition of a case label, and complain if this
5171    is a bad place for one.  */
5172
5173 void
5174 define_case_label ()
5175 {
5176   tree cleanup = last_cleanup_this_contour ();
5177
5178   if (! switch_stack)
5179     /* Don't crash; we'll complain in do_case.  */
5180     return;
5181
5182   if (cleanup)
5183     {
5184       static int explained = 0;
5185       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5186       warning ("where case label appears here");
5187       if (!explained)
5188         {
5189           warning ("(enclose actions of previous case statements requiring");
5190           warning ("destructors in their own binding contours.)");
5191           explained = 1;
5192         }
5193     }
5194
5195   check_switch_goto (switch_stack->level);
5196
5197   /* After labels, make any new cleanups go into their
5198      own new (temporary) binding contour.  */
5199
5200   current_binding_level->more_cleanups_ok = 0;
5201   current_function_return_value = NULL_TREE;
5202 }
5203 \f
5204 /* Return the list of declarations of the current level.
5205    Note that this list is in reverse order unless/until
5206    you nreverse it; and when you do nreverse it, you must
5207    store the result back using `storedecls' or you will lose.  */
5208
5209 tree
5210 getdecls ()
5211 {
5212   return current_binding_level->names;
5213 }
5214
5215 /* Return the list of type-tags (for structs, etc) of the current level.  */
5216
5217 tree
5218 gettags ()
5219 {
5220   return current_binding_level->tags;
5221 }
5222
5223 /* Store the list of declarations of the current level.
5224    This is done for the parameter declarations of a function being defined,
5225    after they are modified in the light of any missing parameters.  */
5226
5227 static void
5228 storedecls (decls)
5229      tree decls;
5230 {
5231   current_binding_level->names = decls;
5232 }
5233
5234 /* Similarly, store the list of tags of the current level.  */
5235
5236 void
5237 storetags (tags)
5238      tree tags;
5239 {
5240   current_binding_level->tags = tags;
5241 }
5242 \f
5243 /* Given NAME, an IDENTIFIER_NODE,
5244    return the structure (or union or enum) definition for that name.
5245    Searches binding levels from BINDING_LEVEL up to the global level.
5246    If THISLEVEL_ONLY is nonzero, searches only the specified context
5247    (but skips any tag-transparent contexts to find one that is
5248    meaningful for tags).
5249    FORM says which kind of type the caller wants;
5250    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5251    If the wrong kind of type is found, and it's not a template, an error is
5252    reported.  */
5253
5254 static tree
5255 lookup_tag (form, name, binding_level, thislevel_only)
5256      enum tree_code form;
5257      tree name;
5258      struct binding_level *binding_level;
5259      int thislevel_only;
5260 {
5261   register struct binding_level *level;
5262   /* Non-zero if, we should look past a template parameter level, even
5263      if THISLEVEL_ONLY.  */
5264   int allow_template_parms_p = 1;
5265
5266   for (level = binding_level; level; level = level->level_chain)
5267     {
5268       register tree tail;
5269       if (ANON_AGGRNAME_P (name))
5270         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5271           {
5272             /* There's no need for error checking here, because
5273                anon names are unique throughout the compilation.  */
5274             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5275               return TREE_VALUE (tail);
5276           }
5277       else if (level->namespace_p)
5278         /* Do namespace lookup. */
5279         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5280           {
5281             tree old = binding_for_name (name, tail);
5282
5283             /* If we just skipped past a template parameter level,
5284                even though THISLEVEL_ONLY, and we find a template
5285                class declaration, then we use the _TYPE node for the
5286                template.  See the example below.  */
5287             if (thislevel_only && !allow_template_parms_p
5288                 && old && BINDING_VALUE (old)
5289                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5290               old = TREE_TYPE (BINDING_VALUE (old));
5291             else
5292               old = BINDING_TYPE (old);
5293
5294             /* If it has an original type, it is a typedef, and we
5295                should not return it.  */
5296             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5297               old = NULL_TREE;
5298             if (old && TREE_CODE (old) != form
5299                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5300               {
5301                 cp_error ("`%#D' redeclared as %C", old, form);
5302                 return NULL_TREE;
5303               }
5304             if (old)
5305               return old;
5306             if (thislevel_only || tail == global_namespace)
5307               return NULL_TREE;
5308           }
5309       else
5310         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5311           {
5312             if (TREE_PURPOSE (tail) == name)
5313               {
5314                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5315                 /* Should tighten this up; it'll probably permit
5316                    UNION_TYPE and a struct template, for example.  */
5317                 if (code != form
5318                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5319                   {
5320                     /* Definition isn't the kind we were looking for.  */
5321                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5322                               form);
5323                     return NULL_TREE;
5324                   }
5325                 return TREE_VALUE (tail);
5326               }
5327           }
5328       if (thislevel_only && ! level->tag_transparent)
5329         {
5330           if (level->template_parms_p && allow_template_parms_p)
5331             {
5332               /* We must deal with cases like this:
5333
5334                    template <class T> struct S;
5335                    template <class T> struct S {};
5336
5337                  When looking up `S', for the second declaration, we
5338                  would like to find the first declaration.  But, we
5339                  are in the pseudo-global level created for the
5340                  template parameters, rather than the (surrounding)
5341                  namespace level.  Thus, we keep going one more level,
5342                  even though THISLEVEL_ONLY is non-zero.  */
5343               allow_template_parms_p = 0;
5344               continue;
5345             }
5346           else
5347             return NULL_TREE;
5348         }
5349     }
5350   return NULL_TREE;
5351 }
5352
5353 #if 0
5354 void
5355 set_current_level_tags_transparency (tags_transparent)
5356      int tags_transparent;
5357 {
5358   current_binding_level->tag_transparent = tags_transparent;
5359 }
5360 #endif
5361
5362 /* Given a type, find the tag that was defined for it and return the tag name.
5363    Otherwise return 0.  However, the value can never be 0
5364    in the cases in which this is used.
5365
5366    C++: If NAME is non-zero, this is the new name to install.  This is
5367    done when replacing anonymous tags with real tag names.  */
5368
5369 static tree
5370 lookup_tag_reverse (type, name)
5371      tree type;
5372      tree name;
5373 {
5374   register struct binding_level *level;
5375
5376   for (level = current_binding_level; level; level = level->level_chain)
5377     {
5378       register tree tail;
5379       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5380         {
5381           if (TREE_VALUE (tail) == type)
5382             {
5383               if (name)
5384                 TREE_PURPOSE (tail) = name;
5385               return TREE_PURPOSE (tail);
5386             }
5387         }
5388     }
5389   return NULL_TREE;
5390 }
5391 \f
5392 /* Look up NAME in the NAMESPACE.  */
5393
5394 tree
5395 lookup_namespace_name (namespace, name)
5396      tree namespace, name;
5397 {
5398   tree val;
5399   tree template_id = NULL_TREE;
5400
5401   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5402
5403   if (TREE_CODE (name) == NAMESPACE_DECL)
5404     /* This happens for A::B<int> when B is a namespace. */
5405     return name;
5406   else if (TREE_CODE (name) == TEMPLATE_DECL)
5407     {
5408       /* This happens for A::B where B is a template, and there are no
5409          template arguments.  */
5410       cp_error ("invalid use of `%D'", name);
5411       return error_mark_node;
5412     }
5413
5414   namespace = ORIGINAL_NAMESPACE (namespace);
5415
5416   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5417     {
5418       template_id = name;
5419       name = TREE_OPERAND (name, 0);
5420       if (TREE_CODE (name) == OVERLOAD)
5421         name = DECL_NAME (OVL_CURRENT (name));
5422       else if (DECL_P (name))
5423         name = DECL_NAME (name);
5424     }
5425
5426   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5427
5428   val = make_node (CPLUS_BINDING);
5429   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5430     return error_mark_node;
5431
5432   if (BINDING_VALUE (val))
5433     {
5434       val = BINDING_VALUE (val);
5435
5436       if (template_id)
5437         {
5438           if (DECL_CLASS_TEMPLATE_P (val))
5439             val = lookup_template_class (val,
5440                                          TREE_OPERAND (template_id, 1),
5441                                          /*in_decl=*/NULL_TREE,
5442                                          /*context=*/NULL_TREE,
5443                                          /*entering_scope=*/0);
5444           else if (DECL_FUNCTION_TEMPLATE_P (val)
5445                    || TREE_CODE (val) == OVERLOAD)
5446             val = lookup_template_function (val,
5447                                             TREE_OPERAND (template_id, 1));
5448           else
5449             {
5450               cp_error ("`%D::%D' is not a template",
5451                         namespace, name);
5452               return error_mark_node;
5453             }
5454         }
5455
5456       /* If we have a single function from a using decl, pull it out.  */
5457       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5458         val = OVL_FUNCTION (val);
5459       return val;
5460     }
5461
5462   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5463   return error_mark_node;
5464 }
5465
5466 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5467
5468 static unsigned long
5469 typename_hash (k)
5470      hash_table_key k;
5471 {
5472   unsigned long hash;
5473   tree t;
5474
5475   t = (tree) k;
5476   hash = (((unsigned long) TYPE_CONTEXT (t))
5477           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5478
5479   return hash;
5480 }
5481
5482 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5483
5484 static boolean
5485 typename_compare (k1, k2)
5486      hash_table_key k1;
5487      hash_table_key k2;
5488 {
5489   tree t1;
5490   tree t2;
5491   tree d1;
5492   tree d2;
5493
5494   t1 = (tree) k1;
5495   t2 = (tree) k2;
5496   d1 = TYPE_NAME (t1);
5497   d2 = TYPE_NAME (t2);
5498
5499   return (DECL_NAME (d1) == DECL_NAME (d2)
5500           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5501           && ((TREE_TYPE (t1) != NULL_TREE)
5502               == (TREE_TYPE (t2) != NULL_TREE))
5503           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5504           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5505 }
5506
5507 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5508    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5509    is non-NULL, this type is being created by the implicit typename
5510    extension, and BASE_TYPE is a type named `t' in some base class of
5511    `T' which depends on template parameters.
5512
5513    Returns the new TYPENAME_TYPE.  */
5514
5515 tree
5516 build_typename_type (context, name, fullname, base_type)
5517      tree context;
5518      tree name;
5519      tree fullname;
5520      tree base_type;
5521 {
5522   tree t;
5523   tree d;
5524   struct hash_entry* e;
5525
5526   static struct hash_table ht;
5527
5528   if (!ht.table)
5529     {
5530       static struct hash_table *h = &ht;
5531       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5532                             &typename_compare))
5533         fatal ("virtual memory exhausted");
5534       ggc_add_tree_hash_table_root (&h, 1);
5535     }
5536
5537   /* Build the TYPENAME_TYPE.  */
5538   t = make_aggr_type (TYPENAME_TYPE);
5539   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5540   TYPENAME_TYPE_FULLNAME (t) = fullname;
5541   TREE_TYPE (t) = base_type;
5542
5543   /* Build the corresponding TYPE_DECL.  */
5544   d = build_decl (TYPE_DECL, name, t);
5545   TYPE_NAME (TREE_TYPE (d)) = d;
5546   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5547   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5548   DECL_ARTIFICIAL (d) = 1;
5549
5550   /* See if we already have this type.  */
5551   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5552   if (e)
5553     t = (tree) e->key;
5554   else
5555     /* Insert the type into the table.  */
5556     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5557
5558   return t;
5559 }
5560
5561 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5562    unless an error occurs, in which case error_mark_node is returned.
5563    If COMPLAIN zero, don't complain about any errors that occur.  */
5564
5565 tree
5566 make_typename_type (context, name, complain)
5567      tree context, name;
5568      int complain;
5569 {
5570   tree fullname;
5571
5572   if (TYPE_P (name))
5573     {
5574       if (!(TYPE_LANG_SPECIFIC (name)
5575             && (CLASSTYPE_IS_TEMPLATE (name)
5576                 || CLASSTYPE_USE_TEMPLATE (name))))
5577         name = TYPE_IDENTIFIER (name);
5578       else
5579         /* Create a TEMPLATE_ID_EXPR for the type.  */
5580         name = build_nt (TEMPLATE_ID_EXPR,
5581                          CLASSTYPE_TI_TEMPLATE (name),
5582                          CLASSTYPE_TI_ARGS (name));
5583     }
5584   else if (TREE_CODE (name) == TYPE_DECL)
5585     name = DECL_NAME (name);
5586
5587   fullname = name;
5588
5589   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5590     {
5591       name = TREE_OPERAND (name, 0);
5592       if (TREE_CODE (name) == TEMPLATE_DECL)
5593         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5594     }
5595   if (TREE_CODE (name) != IDENTIFIER_NODE)
5596     my_friendly_abort (2000);
5597
5598   if (TREE_CODE (context) == NAMESPACE_DECL)
5599     {
5600       /* We can get here from typename_sub0 in the explicit_template_type
5601          expansion.  Just fail.  */
5602       if (complain)
5603         cp_error ("no class template named `%#T' in `%#T'",
5604                   name, context);
5605       return error_mark_node;
5606     }
5607
5608   if (! uses_template_parms (context)
5609       || currently_open_class (context))
5610     {
5611       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5612         {
5613           tree tmpl = NULL_TREE;
5614           if (IS_AGGR_TYPE (context))
5615             tmpl = lookup_field (context, name, 0, 0);
5616           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5617             {
5618               if (complain)
5619                 cp_error ("no class template named `%#T' in `%#T'",
5620                           name, context);
5621               return error_mark_node;
5622             }
5623
5624           return lookup_template_class (tmpl,
5625                                         TREE_OPERAND (fullname, 1),
5626                                         NULL_TREE, context,
5627                                         /*entering_scope=*/0);
5628         }
5629       else
5630         {
5631           tree t;
5632
5633           if (!IS_AGGR_TYPE (context))
5634             {
5635               if (complain)
5636                 cp_error ("no type named `%#T' in `%#T'", name, context);
5637               return error_mark_node;
5638             }
5639
5640           t = lookup_field (context, name, 0, 1);
5641           if (t)
5642             return TREE_TYPE (t);
5643         }
5644     }
5645
5646   /* If the CONTEXT is not a template type, then either the field is
5647      there now or its never going to be.  */
5648   if (!uses_template_parms (context))
5649     {
5650       if (complain)
5651         cp_error ("no type named `%#T' in `%#T'", name, context);
5652       return error_mark_node;
5653     }
5654
5655
5656   return build_typename_type (context, name, fullname,  NULL_TREE);
5657 }
5658
5659 /* Select the right _DECL from multiple choices. */
5660
5661 static tree
5662 select_decl (binding, flags)
5663      tree binding;
5664      int flags;
5665 {
5666   tree val;
5667   val = BINDING_VALUE (binding);
5668   if (LOOKUP_NAMESPACES_ONLY (flags))
5669     {
5670       /* We are not interested in types. */
5671       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5672         return val;
5673       return NULL_TREE;
5674     }
5675
5676   /* If we could have a type and
5677      we have nothing or we need a type and have none.  */
5678   if (BINDING_TYPE (binding)
5679       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5680                    && TREE_CODE (val) != TYPE_DECL)))
5681     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5682   /* Don't return non-types if we really prefer types. */
5683   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5684            && (TREE_CODE (val) != TEMPLATE_DECL
5685                || !DECL_CLASS_TEMPLATE_P (val)))
5686     val = NULL_TREE;
5687
5688   return val;
5689 }
5690
5691 /* Unscoped lookup of a global: iterate over current namespaces,
5692    considering using-directives.  If SPACESP is non-NULL, store a list
5693    of the namespaces we've considered in it.  */
5694
5695 tree
5696 unqualified_namespace_lookup (name, flags, spacesp)
5697      tree name;
5698      int flags;
5699      tree *spacesp;
5700 {
5701   tree b = make_node (CPLUS_BINDING);
5702   tree initial = current_decl_namespace();
5703   tree scope = initial;
5704   tree siter;
5705   struct binding_level *level;
5706   tree val = NULL_TREE;
5707
5708   if (spacesp)
5709     *spacesp = NULL_TREE;
5710
5711   for (; !val; scope = CP_DECL_CONTEXT (scope))
5712     {
5713       if (spacesp)
5714         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5715       val = binding_for_name (name, scope);
5716
5717       /* Initialize binding for this context. */
5718       BINDING_VALUE (b) = BINDING_VALUE (val);
5719       BINDING_TYPE (b) = BINDING_TYPE (val);
5720
5721       /* Add all _DECLs seen through local using-directives. */
5722       for (level = current_binding_level;
5723            !level->namespace_p;
5724            level = level->level_chain)
5725         if (!lookup_using_namespace (name, b, level->using_directives,
5726                                      scope, flags, spacesp))
5727           /* Give up because of error. */
5728           return error_mark_node;
5729
5730       /* Add all _DECLs seen through global using-directives. */
5731       /* XXX local and global using lists should work equally. */
5732       siter = initial;
5733       while (1)
5734         {
5735           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5736                                        scope, flags, spacesp))
5737             /* Give up because of error. */
5738             return error_mark_node;
5739           if (siter == scope) break;
5740           siter = CP_DECL_CONTEXT (siter);
5741         }
5742
5743       val = select_decl (b, flags);
5744       if (scope == global_namespace)
5745         break;
5746     }
5747   return val;
5748 }
5749
5750 /* Combine prefer_type and namespaces_only into flags.  */
5751
5752 static int
5753 lookup_flags (prefer_type, namespaces_only)
5754   int prefer_type, namespaces_only;
5755 {
5756   if (namespaces_only)
5757     return LOOKUP_PREFER_NAMESPACES;
5758   if (prefer_type > 1)
5759     return LOOKUP_PREFER_TYPES;
5760   if (prefer_type > 0)
5761     return LOOKUP_PREFER_BOTH;
5762   return 0;
5763 }
5764
5765 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5766    ignore it or not.  Subroutine of lookup_name_real.  */
5767
5768 static tree
5769 qualify_lookup (val, flags)
5770      tree val;
5771      int flags;
5772 {
5773   if (val == NULL_TREE)
5774     return val;
5775   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5776     return val;
5777   if ((flags & LOOKUP_PREFER_TYPES)
5778       && (TREE_CODE (val) == TYPE_DECL
5779           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5780               && DECL_CLASS_TEMPLATE_P (val))))
5781     return val;
5782   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5783     return NULL_TREE;
5784   return val;
5785 }
5786
5787 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5788    that.  */
5789
5790 static void
5791 warn_about_implicit_typename_lookup (typename, binding)
5792      tree typename;
5793      tree binding;
5794 {
5795   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5796   tree name = DECL_NAME (typename);
5797
5798   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5799          && CLASSTYPE_TEMPLATE_INFO (subtype)
5800          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5801       && ! (TREE_CODE (binding) == TYPE_DECL
5802             && same_type_p (TREE_TYPE (binding), subtype)))
5803     {
5804       cp_warning ("lookup of `%D' finds `%#D'",
5805                   name, binding);
5806       cp_warning ("  instead of `%D' from dependent base class",
5807                   typename);
5808       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5809                   constructor_name (current_class_type), name);
5810     }
5811 }
5812
5813 /* Look up NAME in the current binding level and its superiors in the
5814    namespace of variables, functions and typedefs.  Return a ..._DECL
5815    node of some kind representing its definition if there is only one
5816    such declaration, or return a TREE_LIST with all the overloaded
5817    definitions if there are many, or return 0 if it is undefined.
5818
5819    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5820    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5821    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5822    Otherwise we prefer non-TYPE_DECLs.
5823
5824    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5825    using IDENTIFIER_CLASS_VALUE.  */
5826
5827 static tree
5828 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5829      tree name;
5830      int prefer_type, nonclass, namespaces_only;
5831 {
5832   tree t;
5833   tree val = NULL_TREE;
5834   int yylex = 0;
5835   tree from_obj = NULL_TREE;
5836   int flags;
5837   int val_is_implicit_typename = 0;
5838
5839   /* Hack: copy flag set by parser, if set. */
5840   if (only_namespace_names)
5841     namespaces_only = 1;
5842
5843   if (prefer_type == -2)
5844     {
5845       extern int looking_for_typename;
5846       tree type = NULL_TREE;
5847
5848       yylex = 1;
5849       prefer_type = looking_for_typename;
5850
5851       flags = lookup_flags (prefer_type, namespaces_only);
5852       /* If the next thing is '<', class templates are types. */
5853       if (looking_for_template)
5854         flags |= LOOKUP_TEMPLATES_EXPECTED;
5855
5856       /* std:: becomes :: for now.  */
5857       if (got_scope == std_node)
5858         got_scope = void_type_node;
5859
5860       if (got_scope)
5861         type = got_scope;
5862       else if (got_object != error_mark_node)
5863         type = got_object;
5864
5865       if (type)
5866         {
5867           if (type == error_mark_node)
5868             return error_mark_node;
5869           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5870             type = TREE_TYPE (type);
5871
5872           if (TYPE_P (type))
5873             type = complete_type (type);
5874
5875           if (TREE_CODE (type) == VOID_TYPE)
5876             type = global_namespace;
5877           if (TREE_CODE (type) == NAMESPACE_DECL)
5878             {
5879               val = make_node (CPLUS_BINDING);
5880               flags |= LOOKUP_COMPLAIN;
5881               if (!qualified_lookup_using_namespace (name, type, val, flags))
5882                 return NULL_TREE;
5883               val = select_decl (val, flags);
5884             }
5885           else if (! IS_AGGR_TYPE (type)
5886                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5887                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5888                    || TREE_CODE (type) == TYPENAME_TYPE)
5889             /* Someone else will give an error about this if needed.  */
5890             val = NULL_TREE;
5891           else if (type == current_class_type)
5892             val = IDENTIFIER_CLASS_VALUE (name);
5893           else
5894             {
5895               val = lookup_member (type, name, 0, prefer_type);
5896               type_access_control (type, val);
5897             }
5898         }
5899       else
5900         val = NULL_TREE;
5901
5902       if (got_scope)
5903         goto done;
5904       else if (got_object && val)
5905         from_obj = val;
5906     }
5907   else
5908     {
5909       flags = lookup_flags (prefer_type, namespaces_only);
5910       /* If we're not parsing, we need to complain. */
5911       flags |= LOOKUP_COMPLAIN;
5912     }
5913
5914   /* First, look in non-namespace scopes.  */
5915
5916   if (current_class_type == NULL_TREE)
5917     nonclass = 1;
5918
5919   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5920     {
5921       tree binding;
5922
5923       if (!LOCAL_BINDING_P (t) && nonclass)
5924         /* We're not looking for class-scoped bindings, so keep going.  */
5925         continue;
5926
5927       /* If this is the kind of thing we're looking for, we're done.  */
5928       if (qualify_lookup (BINDING_VALUE (t), flags))
5929         binding = BINDING_VALUE (t);
5930       else if ((flags & LOOKUP_PREFER_TYPES)
5931                && qualify_lookup (BINDING_TYPE (t), flags))
5932         binding = BINDING_TYPE (t);
5933       else
5934         binding = NULL_TREE;
5935
5936       /* Handle access control on types from enclosing or base classes.  */
5937       if (binding && ! yylex
5938           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5939         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5940
5941       if (binding
5942           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5943         {
5944           if (val_is_implicit_typename && !yylex)
5945             warn_about_implicit_typename_lookup (val, binding);
5946           val = binding;
5947           val_is_implicit_typename
5948             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5949           if (!val_is_implicit_typename)
5950             break;
5951         }
5952     }
5953
5954   /* Now lookup in namespace scopes.  */
5955   if (!val || val_is_implicit_typename)
5956     {
5957       t = unqualified_namespace_lookup (name, flags, 0);
5958       if (t)
5959         {
5960           if (val_is_implicit_typename && !yylex)
5961             warn_about_implicit_typename_lookup (val, t);
5962           val = t;
5963         }
5964     }
5965
5966  done:
5967   if (val)
5968     {
5969       /* This should only warn about types used in qualified-ids.  */
5970       if (from_obj && from_obj != val)
5971         {
5972           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5973               && TREE_CODE (val) == TYPE_DECL
5974               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5975             {
5976               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5977                           name, got_object, TREE_TYPE (from_obj));
5978               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5979                           TREE_TYPE (val));
5980             }
5981
5982           /* We don't change val to from_obj if got_object depends on
5983              template parms because that breaks implicit typename for
5984              destructor calls.  */
5985           if (! uses_template_parms (got_object))
5986             val = from_obj;
5987         }
5988
5989       /* If we have a single function from a using decl, pull it out.  */
5990       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5991         val = OVL_FUNCTION (val);
5992     }
5993   else if (from_obj)
5994     val = from_obj;
5995
5996   return val;
5997 }
5998
5999 tree
6000 lookup_name_nonclass (name)
6001      tree name;
6002 {
6003   return lookup_name_real (name, 0, 1, 0);
6004 }
6005
6006 tree
6007 lookup_function_nonclass (name, args)
6008      tree name;
6009      tree args;
6010 {
6011   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6012 }
6013
6014 tree
6015 lookup_name_namespace_only (name)
6016      tree name;
6017 {
6018   /* type-or-namespace, nonclass, namespace_only */
6019   return lookup_name_real (name, 1, 1, 1);
6020 }
6021
6022 tree
6023 lookup_name (name, prefer_type)
6024      tree name;
6025      int prefer_type;
6026 {
6027   return lookup_name_real (name, prefer_type, 0, 0);
6028 }
6029
6030 /* Similar to `lookup_name' but look only in the innermost non-class
6031    binding level.  */
6032
6033 tree
6034 lookup_name_current_level (name)
6035      tree name;
6036 {
6037   struct binding_level *b;
6038   tree t = NULL_TREE;
6039
6040   b = current_binding_level;
6041   while (b->parm_flag == 2)
6042     b = b->level_chain;
6043
6044   if (b->namespace_p)
6045     {
6046       t = IDENTIFIER_NAMESPACE_VALUE (name);
6047
6048       /* extern "C" function() */
6049       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6050         t = TREE_VALUE (t);
6051     }
6052   else if (IDENTIFIER_BINDING (name)
6053            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6054     {
6055       while (1)
6056         {
6057           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6058             return IDENTIFIER_VALUE (name);
6059
6060           if (b->keep == 2)
6061             b = b->level_chain;
6062           else
6063             break;
6064         }
6065     }
6066
6067   return t;
6068 }
6069
6070 /* Like lookup_name_current_level, but for types.  */
6071
6072 tree
6073 lookup_type_current_level (name)
6074      tree name;
6075 {
6076   register tree t = NULL_TREE;
6077
6078   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6079
6080   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6081       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6082     {
6083       struct binding_level *b = current_binding_level;
6084       while (1)
6085         {
6086           if (purpose_member (name, b->type_shadowed))
6087             return REAL_IDENTIFIER_TYPE_VALUE (name);
6088           if (b->keep == 2)
6089             b = b->level_chain;
6090           else
6091             break;
6092         }
6093     }
6094
6095   return t;
6096 }
6097
6098 void
6099 begin_only_namespace_names ()
6100 {
6101   only_namespace_names = 1;
6102 }
6103
6104 void
6105 end_only_namespace_names ()
6106 {
6107   only_namespace_names = 0;
6108 }
6109 \f
6110 /* Push the declarations of builtin types into the namespace.
6111    RID_INDEX, if < CP_RID_MAX is the index of the builtin type
6112    in the array RID_POINTERS.  NAME is the name used when looking
6113    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6114
6115 static void
6116 record_builtin_type (rid_index, name, type)
6117      enum rid rid_index;
6118      const char *name;
6119      tree type;
6120 {
6121   tree rname = NULL_TREE, tname = NULL_TREE;
6122   tree tdecl = NULL_TREE;
6123
6124   if ((int) rid_index < (int) CP_RID_MAX)
6125     rname = ridpointers[(int) rid_index];
6126   if (name)
6127     tname = get_identifier (name);
6128
6129   TYPE_BUILT_IN (type) = 1;
6130
6131   if (tname)
6132     {
6133       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6134       set_identifier_type_value (tname, NULL_TREE);
6135       if ((int) rid_index < (int) CP_RID_MAX)
6136         /* Built-in types live in the global namespace. */
6137         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6138     }
6139   if (rname != NULL_TREE)
6140     {
6141       if (tname != NULL_TREE)
6142         {
6143           set_identifier_type_value (rname, NULL_TREE);
6144           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6145         }
6146       else
6147         {
6148           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6149           set_identifier_type_value (rname, NULL_TREE);
6150         }
6151     }
6152 }
6153
6154 /* Record one of the standard Java types.
6155  * Declare it as having the given NAME.
6156  * If SIZE > 0, it is the size of one of the integral types;
6157  * otherwise it is the negative of the size of one of the other types.  */
6158
6159 static tree
6160 record_builtin_java_type (name, size)
6161      const char *name;
6162      int size;
6163 {
6164   tree type, decl;
6165   if (size > 0)
6166     type = make_signed_type (size);
6167   else if (size > -32)
6168     { /* "__java_char" or ""__java_boolean". */
6169       type = make_unsigned_type (-size);
6170       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6171     }
6172   else
6173     { /* "__java_float" or ""__java_double". */
6174       type = make_node (REAL_TYPE);
6175       TYPE_PRECISION (type) = - size;
6176       layout_type (type);
6177     }
6178   record_builtin_type (CP_RID_MAX, name, type);
6179   decl = TYPE_NAME (type);
6180
6181   /* Suppress generate debug symbol entries for these types,
6182      since for normal C++ they are just clutter.
6183      However, push_lang_context undoes this if extern "Java" is seen. */
6184   DECL_IGNORED_P (decl) = 1;
6185
6186   TYPE_FOR_JAVA (type) = 1;
6187   return type;
6188 }
6189
6190 /* Push a type into the namespace so that the back-ends ignore it. */
6191
6192 static void
6193 record_unknown_type (type, name)
6194      tree type;
6195      const char *name;
6196 {
6197   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6198   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6199   DECL_IGNORED_P (decl) = 1;
6200   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6201   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6202   TYPE_ALIGN (type) = 1;
6203   TYPE_USER_ALIGN (type) = 0;
6204   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6205 }
6206
6207 /* An string for which we should create an IDENTIFIER_NODE at
6208    startup.  */
6209
6210 typedef struct predefined_identifier
6211 {
6212   /* The name of the identifier.  */
6213   const char *name;
6214   /* The place where the IDENTIFIER_NODE should be stored.  */
6215   tree *node;
6216   /* Non-zero if this is the name of a constructor or destructor.  */
6217   int ctor_or_dtor_p;
6218 } predefined_identifier;
6219
6220 /* Create all the predefined identifiers.  */
6221
6222 static void
6223 initialize_predefined_identifiers ()
6224 {
6225   struct predefined_identifier *pid;
6226
6227   /* A table of identifiers to create at startup.  */
6228   static predefined_identifier predefined_identifiers[] = {
6229     { "C++", &lang_name_cplusplus, 0 },
6230     { "C", &lang_name_c, 0 },
6231     { "Java", &lang_name_java, 0 },
6232     { CTOR_NAME, &ctor_identifier, 1 },
6233     { "__base_ctor", &base_ctor_identifier, 1 },
6234     { "__comp_ctor", &complete_ctor_identifier, 1 },
6235     { DTOR_NAME, &dtor_identifier, 1 },
6236     { "__comp_dtor", &complete_dtor_identifier, 1 },
6237     { "__base_dtor", &base_dtor_identifier, 1 },
6238     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6239     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6240     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6241     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6242     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6243     { "nelts", &nelts_identifier, 0 },
6244     { THIS_NAME, &this_identifier, 0 },
6245     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6246     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6247     { "_vptr", &vptr_identifier, 0 },
6248     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6249     { "__vtt_parm", &vtt_parm_identifier, 0 },
6250     { "std", &std_identifier, 0 },
6251     { NULL, NULL, 0 }
6252   };
6253
6254   for (pid = predefined_identifiers; pid->name; ++pid)
6255     {
6256       *pid->node = get_identifier (pid->name);
6257       if (pid->ctor_or_dtor_p)
6258         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6259     }
6260 }
6261
6262 /* Create the predefined scalar types of C,
6263    and some nodes representing standard constants (0, 1, (void *)0).
6264    Initialize the global binding level.
6265    Make definitions for built-in primitive functions.  */
6266
6267 void
6268 init_decl_processing ()
6269 {
6270   tree fields[20];
6271   int wchar_type_size;
6272   tree array_domain_type;
6273
6274   /* Check to see that the user did not specify an invalid combination
6275      of command-line options.  */
6276   if (flag_new_abi && !flag_vtable_thunks)
6277     fatal ("the new ABI requires vtable thunks");
6278
6279   /* Create all the identifiers we need.  */
6280   initialize_predefined_identifiers ();
6281
6282   /* Let the back-end now how to save and restore language-specific
6283      per-function globals.  */
6284   init_lang_status = &push_cp_function_context;
6285   free_lang_status = &pop_cp_function_context;
6286   mark_lang_status = &mark_cp_function_context;
6287
6288   cp_parse_init ();
6289   init_decl2 ();
6290   init_pt ();
6291
6292   /* Create the global variables.  */
6293   push_to_top_level ();
6294
6295   /* Enter the global namespace. */
6296   my_friendly_assert (global_namespace == NULL_TREE, 375);
6297   push_namespace (get_identifier ("::"));
6298   global_namespace = current_namespace;
6299   current_lang_name = NULL_TREE;
6300
6301   /* Adjust various flags based on command-line settings.  */
6302   if (! flag_permissive && ! pedantic)
6303     flag_pedantic_errors = 1;
6304   if (!flag_no_inline)
6305     flag_inline_trees = 1;
6306
6307   /* Initially, C.  */
6308   current_lang_name = lang_name_c;
6309
6310   current_function_decl = NULL_TREE;
6311   current_binding_level = NULL_BINDING_LEVEL;
6312   free_binding_level = NULL_BINDING_LEVEL;
6313
6314   build_common_tree_nodes (flag_signed_char);
6315
6316   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6317   TREE_TYPE (error_mark_list) = error_mark_node;
6318
6319   /* Make the binding_level structure for global names.  */
6320   pushlevel (0);
6321   global_binding_level = current_binding_level;
6322   /* The global level is the namespace level of ::.  */
6323   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6324   declare_namespace_level ();
6325
6326   /* Define `int' and `char' first so that dbx will output them first.  */
6327   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6328   record_builtin_type (RID_CHAR, "char", char_type_node);
6329
6330   /* `signed' is the same as `int' */
6331   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6332   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6333   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6334   record_builtin_type (CP_RID_MAX, "long unsigned int",
6335                        long_unsigned_type_node);
6336   record_builtin_type (CP_RID_MAX, "unsigned long", long_unsigned_type_node);
6337   record_builtin_type (CP_RID_MAX, "long long int",
6338                        long_long_integer_type_node);
6339   record_builtin_type (CP_RID_MAX, "long long unsigned int",
6340                        long_long_unsigned_type_node);
6341   record_builtin_type (CP_RID_MAX, "long long unsigned",
6342                        long_long_unsigned_type_node);
6343   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6344   record_builtin_type (CP_RID_MAX, "short unsigned int",
6345                        short_unsigned_type_node);
6346   record_builtin_type (CP_RID_MAX, "unsigned short",
6347                        short_unsigned_type_node);
6348
6349   ptrdiff_type_node
6350     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6351
6352   /* Define both `signed char' and `unsigned char'.  */
6353   record_builtin_type (CP_RID_MAX, "signed char", signed_char_type_node);
6354   record_builtin_type (CP_RID_MAX, "unsigned char", unsigned_char_type_node);
6355
6356   /* `unsigned long' is the standard type for sizeof.
6357      Note that stddef.h uses `unsigned long',
6358      and this must agree, even if long and int are the same size.  */
6359   set_sizetype
6360     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6361
6362   /* Create the widest literal types. */
6363   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6364   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6365                         widest_integer_literal_type_node));
6366
6367   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6368   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6369                         widest_unsigned_literal_type_node));
6370
6371   /* These are types that type_for_size and type_for_mode use.  */
6372   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6373   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6374   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6375   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6376 #if HOST_BITS_PER_WIDE_INT >= 64
6377   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6378 #endif
6379   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6380   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6381   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6382   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6383 #if HOST_BITS_PER_WIDE_INT >= 64
6384   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6385 #endif
6386
6387   build_common_tree_nodes_2 (flag_short_double);
6388
6389   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6390   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6391   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6392   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6393   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6394   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6395   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6396   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6397
6398   integer_two_node = build_int_2 (2, 0);
6399   TREE_TYPE (integer_two_node) = integer_type_node;
6400   integer_three_node = build_int_2 (3, 0);
6401   TREE_TYPE (integer_three_node) = integer_type_node;
6402
6403   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6404   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6405   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6406   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6407   TYPE_PRECISION (boolean_type_node) = 1;
6408   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6409   boolean_false_node = build_int_2 (0, 0);
6410   TREE_TYPE (boolean_false_node) = boolean_type_node;
6411   boolean_true_node = build_int_2 (1, 0);
6412   TREE_TYPE (boolean_true_node) = boolean_type_node;
6413
6414   signed_size_zero_node = build_int_2 (0, 0);
6415   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6416   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6417   record_builtin_type (CP_RID_MAX, "long double", long_double_type_node);
6418
6419   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6420                         complex_integer_type_node));
6421   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6422                         complex_float_type_node));
6423   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6424                         complex_double_type_node));
6425   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6426                         complex_long_double_type_node));
6427
6428   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6429
6430   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6431   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6432   TREE_PARMLIST (void_list_node) = 1;
6433
6434   /* Used for expressions that do nothing, but are not errors.  */
6435   void_zero_node = build_int_2 (0, 0);
6436   TREE_TYPE (void_zero_node) = void_type_node;
6437
6438   string_type_node = build_pointer_type (char_type_node);
6439   const_string_type_node
6440     = build_pointer_type (build_qualified_type (char_type_node,
6441                                                 TYPE_QUAL_CONST));
6442   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6443 #if 0
6444   record_builtin_type (CP_RID_MAX, NULL_PTR, string_type_node);
6445 #endif
6446
6447   /* Make a type to be the domain of a few array types
6448      whose domains don't really matter.
6449      200 is small enough that it always fits in size_t.  */
6450   array_domain_type = build_index_type (build_int_2 (200, 0));
6451
6452   /* Make a type for arrays of characters.
6453      With luck nothing will ever really depend on the length of this
6454      array type.  */
6455   char_array_type_node
6456     = build_array_type (char_type_node, array_domain_type);
6457
6458   /* Likewise for arrays of ints.  */
6459   int_array_type_node
6460     = build_array_type (integer_type_node, array_domain_type);
6461
6462   if (flag_new_abi)
6463     delta_type_node = ptrdiff_type_node;
6464   else if (flag_huge_objects)
6465     delta_type_node = long_integer_type_node;
6466   else
6467     delta_type_node = short_integer_type_node;
6468
6469   if (flag_new_abi)
6470     vtable_index_type = ptrdiff_type_node;
6471   else
6472     vtable_index_type = delta_type_node;
6473
6474   default_function_type
6475     = build_function_type (integer_type_node, NULL_TREE);
6476
6477   ptr_type_node = build_pointer_type (void_type_node);
6478   const_ptr_type_node
6479     = build_pointer_type (build_qualified_type (void_type_node,
6480                                                 TYPE_QUAL_CONST));
6481   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6482   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6483   lang_type_promotes_to = convert_type_from_ellipsis;
6484
6485   void_ftype_ptr
6486     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6487
6488   /* C++ extensions */
6489
6490   unknown_type_node = make_node (UNKNOWN_TYPE);
6491   record_unknown_type (unknown_type_node, "unknown type");
6492
6493   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6494   TREE_TYPE (unknown_type_node) = unknown_type_node;
6495
6496   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6497
6498   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6499      result.  */
6500   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6501   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6502
6503   /* This is special for C++ so functions can be overloaded.  */
6504   wchar_type_node = get_identifier (flag_short_wchar
6505                                     ? "short unsigned int"
6506                                     : WCHAR_TYPE);
6507   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6508   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6509   if (TREE_UNSIGNED (wchar_type_node))
6510     wchar_type_node = make_signed_type (wchar_type_size);
6511   else
6512     wchar_type_node = make_unsigned_type (wchar_type_size);
6513   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6514
6515   /* Artificial declaration of wchar_t -- can be bashed */
6516   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6517                                 wchar_type_node);
6518   pushdecl (wchar_decl_node);
6519
6520   /* This is for wide string constants.  */
6521   wchar_array_type_node
6522     = build_array_type (wchar_type_node, array_domain_type);
6523
6524   if (flag_vtable_thunks)
6525     {
6526       /* Make sure we get a unique function type, so we can give
6527          its pointer type a name.  (This wins for gdb.) */
6528       tree vfunc_type = make_node (FUNCTION_TYPE);
6529       TREE_TYPE (vfunc_type) = integer_type_node;
6530       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6531       layout_type (vfunc_type);
6532
6533       vtable_entry_type = build_pointer_type (vfunc_type);
6534     }
6535   else
6536     {
6537       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6538       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6539                               delta_type_node);
6540       fields[1] = build_decl (FIELD_DECL, index_identifier,
6541                               delta_type_node);
6542       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6543                               ptr_type_node);
6544       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6545                            double_type_node);
6546
6547       /* Make this part of an invisible union.  */
6548       fields[3] = copy_node (fields[2]);
6549       TREE_TYPE (fields[3]) = delta_type_node;
6550       DECL_NAME (fields[3]) = delta2_identifier;
6551       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6552       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6553       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6554       TREE_UNSIGNED (fields[3]) = 0;
6555       TREE_CHAIN (fields[2]) = fields[3];
6556       vtable_entry_type = build_qualified_type (vtable_entry_type,
6557                                                 TYPE_QUAL_CONST);
6558     }
6559   record_builtin_type (CP_RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6560
6561   vtbl_type_node
6562     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6563   layout_type (vtbl_type_node);
6564   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6565   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_type_node);
6566   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6567   layout_type (vtbl_ptr_type_node);
6568   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6569
6570   std_node = build_decl (NAMESPACE_DECL,
6571                          flag_honor_std
6572                          ? get_identifier ("fake std") : std_identifier,
6573                          void_type_node);
6574   pushdecl (std_node);
6575
6576   if (flag_new_abi)
6577     {
6578       push_namespace (get_identifier ("__cxxabiv1"));
6579       abi_node = current_namespace;
6580       pop_namespace ();
6581     }
6582
6583   global_type_node = make_node (LANG_TYPE);
6584   record_unknown_type (global_type_node, "global type");
6585
6586   /* Now, C++.  */
6587   current_lang_name = lang_name_cplusplus;
6588
6589   {
6590     tree bad_alloc_type_node, newtype, deltype;
6591     if (flag_honor_std)
6592       push_namespace (get_identifier ("std"));
6593     bad_alloc_type_node = xref_tag
6594       (class_type_node, get_identifier ("bad_alloc"), 1);
6595     if (flag_honor_std)
6596       pop_namespace ();
6597     newtype = build_exception_variant
6598       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6599     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6600     push_cp_library_fn (NEW_EXPR, newtype);
6601     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6602     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6603     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6604   }
6605
6606   abort_fndecl
6607     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6608
6609   /* Perform other language dependent initializations.  */
6610   init_class_processing ();
6611   init_init_processing ();
6612   init_search_processing ();
6613   init_rtti_processing ();
6614
6615   if (flag_exceptions)
6616     init_exception_processing ();
6617   if (flag_no_inline)
6618     {
6619       flag_inline_functions = 0;
6620     }
6621
6622   if (! supports_one_only ())
6623     flag_weak = 0;
6624
6625   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6626   make_fname_decl = cp_make_fname_decl;
6627   declare_function_name ();
6628
6629   /* Prepare to check format strings against argument lists.  */
6630   init_function_format_info ();
6631
6632   /* Show we use EH for cleanups.  */
6633   using_eh_for_cleanups ();
6634
6635   print_error_function = lang_print_error_function;
6636   valid_lang_attribute = cp_valid_lang_attribute;
6637
6638   /* Maintain consistency.  Perhaps we should just complain if they
6639      say -fwritable-strings?  */
6640   if (flag_writable_strings)
6641     flag_const_strings = 0;
6642
6643   /* Add GC roots for all of our global variables.  */
6644   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6645   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6646   ggc_add_tree_root (&integer_three_node, 1);
6647   ggc_add_tree_root (&integer_two_node, 1);
6648   ggc_add_tree_root (&signed_size_zero_node, 1);
6649   ggc_add_tree_root (&size_one_node, 1);
6650   ggc_add_tree_root (&size_zero_node, 1);
6651   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6652                 mark_binding_level);
6653   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6654   ggc_add_tree_root (&static_ctors, 1);
6655   ggc_add_tree_root (&static_dtors, 1);
6656   ggc_add_tree_root (&lastiddecl, 1);
6657
6658   ggc_add_tree_root (&last_function_parm_tags, 1);
6659   ggc_add_tree_root (&current_function_return_value, 1);
6660   ggc_add_tree_root (&current_function_parms, 1);
6661   ggc_add_tree_root (&current_function_parm_tags, 1);
6662   ggc_add_tree_root (&last_function_parms, 1);
6663   ggc_add_tree_root (&error_mark_list, 1);
6664
6665   ggc_add_tree_root (&global_namespace, 1);
6666   ggc_add_tree_root (&global_type_node, 1);
6667   ggc_add_tree_root (&anonymous_namespace_name, 1);
6668
6669   ggc_add_tree_root (&got_object, 1);
6670   ggc_add_tree_root (&got_scope, 1);
6671
6672   ggc_add_tree_root (&current_lang_name, 1);
6673   ggc_add_tree_root (&static_aggregates, 1);
6674 }
6675
6676 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6677    decl, NAME is the initialization string and TYPE_DEP indicates whether
6678    NAME depended on the type of the function. We make use of that to detect
6679    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6680    the function before emitting any of it, we don't need to treat the
6681    VAR_DECL specially. We can decide whether to emit it later, if it was
6682    used.  */
6683
6684 static tree
6685 cp_make_fname_decl (id, name, type_dep)
6686      tree id;
6687      const char *name;
6688      int type_dep;
6689 {
6690   tree decl, type, init;
6691   size_t length = strlen (name);
6692   tree domain = NULL_TREE;
6693
6694   if (!processing_template_decl)
6695     type_dep = 0;
6696   if (!type_dep)
6697     domain = build_index_type (build_int_2 (length, 0));
6698
6699   type =  build_cplus_array_type
6700           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6701            domain);
6702
6703   decl = build_decl (VAR_DECL, id, type);
6704   TREE_STATIC (decl) = 1;
6705   TREE_READONLY (decl) = 1;
6706   DECL_SOURCE_LINE (decl) = 0;
6707   DECL_ARTIFICIAL (decl) = 1;
6708   DECL_IN_SYSTEM_HEADER (decl) = 1;
6709   pushdecl (decl);
6710   if (processing_template_decl)
6711     decl = push_template_decl (decl);
6712   if (type_dep)
6713     {
6714       init = build (FUNCTION_NAME, type);
6715       DECL_PRETTY_FUNCTION_P (decl) = 1;
6716     }
6717   else
6718     {
6719       init = build_string (length + 1, name);
6720       TREE_TYPE (init) = type;
6721     }
6722   DECL_INITIAL (decl) = init;
6723   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6724
6725   /* We will have to make sure we only emit this, if it is actually used. */
6726   return decl;
6727 }
6728
6729 /* Function to print any language-specific context for an error message.  */
6730
6731 static void
6732 lang_print_error_function (file)
6733      const char *file;
6734 {
6735   default_print_error_function (file);
6736   maybe_print_template_context ();
6737 }
6738
6739 /* Entry point for the benefit of c_common_nodes_and_builtins.
6740
6741    Make a definition for a builtin function named NAME and whose data type
6742    is TYPE.  TYPE should be a function type with argument types.
6743
6744    CLASS and CODE tell later passes how to compile calls to this function.
6745    See tree.h for possible values.
6746
6747    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6748    the name to be called if we can't opencode the function.  */
6749
6750 tree
6751 builtin_function (name, type, code, class, libname)
6752      const char *name;
6753      tree type;
6754      int code;
6755      enum built_in_class class;
6756      const char *libname;
6757 {
6758   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6759   DECL_BUILT_IN_CLASS (decl) = class;
6760   DECL_FUNCTION_CODE (decl) = code;
6761
6762   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6763
6764   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6765      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6766      function in the namespace.  */
6767   pushdecl (decl);
6768   if (libname)
6769     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6770   make_function_rtl (decl);
6771
6772   /* Warn if a function in the namespace for users
6773      is used without an occasion to consider it declared.  */
6774   if (name[0] != '_' || name[1] != '_')
6775     DECL_ANTICIPATED (decl) = 1;
6776
6777   return decl;
6778 }
6779
6780 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6781    function.  Not called directly.  */
6782
6783 static tree
6784 build_library_fn_1 (name, operator_code, type)
6785      tree name;
6786      enum tree_code operator_code;
6787      tree type;
6788 {
6789   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6790   DECL_EXTERNAL (fn) = 1;
6791   TREE_PUBLIC (fn) = 1;
6792   DECL_ARTIFICIAL (fn) = 1;
6793   TREE_NOTHROW (fn) = 1;
6794   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6795   return fn;
6796 }
6797
6798 /* Returns the _DECL for a library function with C linkage.
6799    We assume that such functions never throw; if this is incorrect,
6800    callers should unset TREE_NOTHROW.  */
6801
6802 tree
6803 build_library_fn (name, type)
6804      tree name;
6805      tree type;
6806 {
6807   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6808   make_function_rtl (fn);
6809   return fn;
6810 }
6811
6812 /* Returns the _DECL for a library function with C++ linkage.  */
6813
6814 static tree
6815 build_cp_library_fn (name, operator_code, type)
6816      tree name;
6817      enum tree_code operator_code;
6818      tree type;
6819 {
6820   tree fn = build_library_fn_1 (name, operator_code, type);
6821   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6822   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6823   set_mangled_name_for_decl (fn);
6824   make_function_rtl (fn);
6825   return fn;
6826 }
6827
6828 /* Like build_library_fn, but takes a C string instead of an
6829    IDENTIFIER_NODE.  */
6830
6831 tree
6832 build_library_fn_ptr (name, type)
6833      const char *name;
6834      tree type;
6835 {
6836   return build_library_fn (get_identifier (name), type);
6837 }
6838
6839 /* Like build_cp_library_fn, but takes a C string instead of an
6840    IDENTIFIER_NODE.  */
6841
6842 tree
6843 build_cp_library_fn_ptr (name, type)
6844      const char *name;
6845      tree type;
6846 {
6847   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6848 }
6849
6850 /* Like build_library_fn, but also pushes the function so that we will
6851    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6852
6853 tree
6854 push_library_fn (name, type)
6855      tree name, type;
6856 {
6857   tree fn = build_library_fn (name, type);
6858   pushdecl_top_level (fn);
6859   return fn;
6860 }
6861
6862 /* Like build_cp_library_fn, but also pushes the function so that it
6863    will be found by normal lookup.  */
6864
6865 static tree
6866 push_cp_library_fn (operator_code, type)
6867      enum tree_code operator_code;
6868      tree type;
6869 {
6870   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6871                                  operator_code,
6872                                  type);
6873   pushdecl (fn);
6874   return fn;
6875 }
6876
6877 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6878    a FUNCTION_TYPE.  */
6879
6880 tree
6881 push_void_library_fn (name, parmtypes)
6882      tree name, parmtypes;
6883 {
6884   tree type = build_function_type (void_type_node, parmtypes);
6885   return push_library_fn (name, type);
6886 }
6887
6888 /* Like push_library_fn, but also note that this function throws
6889    and does not return.  Used for __throw_foo and the like.  */
6890
6891 tree
6892 push_throw_library_fn (name, type)
6893      tree name, type;
6894 {
6895   tree fn = push_library_fn (name, type);
6896   TREE_THIS_VOLATILE (fn) = 1;
6897   TREE_NOTHROW (fn) = 0;
6898   return fn;
6899 }
6900 \f
6901 /* When we call finish_struct for an anonymous union, we create
6902    default copy constructors and such.  But, an anonymous union
6903    shouldn't have such things; this function undoes the damage to the
6904    anonymous union type T.
6905
6906    (The reason that we create the synthesized methods is that we don't
6907    distinguish `union { int i; }' from `typedef union { int i; } U'.
6908    The first is an anonymous union; the second is just an ordinary
6909    union type.)  */
6910
6911 void
6912 fixup_anonymous_aggr (t)
6913      tree t;
6914 {
6915   tree *q;
6916
6917   /* Wipe out memory of synthesized methods */
6918   TYPE_HAS_CONSTRUCTOR (t) = 0;
6919   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6920   TYPE_HAS_INIT_REF (t) = 0;
6921   TYPE_HAS_CONST_INIT_REF (t) = 0;
6922   TYPE_HAS_ASSIGN_REF (t) = 0;
6923   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6924
6925   /* Splice the implicitly generated functions out of the TYPE_METHODS
6926      list.  */
6927   q = &TYPE_METHODS (t);
6928   while (*q)
6929     {
6930       if (DECL_ARTIFICIAL (*q))
6931         *q = TREE_CHAIN (*q);
6932       else
6933         q = &TREE_CHAIN (*q);
6934     }
6935
6936   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6937   if (TYPE_METHODS (t))
6938     error ("an anonymous union cannot have function members");
6939 }
6940
6941 /* Make sure that a declaration with no declarator is well-formed, i.e.
6942    just defines a tagged type or anonymous union.
6943
6944    Returns the type defined, if any.  */
6945
6946 tree
6947 check_tag_decl (declspecs)
6948      tree declspecs;
6949 {
6950   int found_type = 0;
6951   int saw_friend = 0;
6952   tree ob_modifier = NULL_TREE;
6953   register tree link;
6954   register tree t = NULL_TREE;
6955
6956   for (link = declspecs; link; link = TREE_CHAIN (link))
6957     {
6958       register tree value = TREE_VALUE (link);
6959
6960       if (TYPE_P (value)
6961           || (TREE_CODE (value) == IDENTIFIER_NODE
6962               && IDENTIFIER_GLOBAL_VALUE (value)
6963               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6964         {
6965           ++found_type;
6966
6967           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6968             {
6969               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6970               t = value;
6971             }
6972         }
6973       else if (value == ridpointers[(int) RID_FRIEND])
6974         {
6975           if (current_class_type == NULL_TREE
6976               || current_scope () != current_class_type)
6977             ob_modifier = value;
6978           else
6979             saw_friend = 1;
6980         }
6981       else if (value == ridpointers[(int) RID_STATIC]
6982                || value == ridpointers[(int) RID_EXTERN]
6983                || value == ridpointers[(int) RID_AUTO]
6984                || value == ridpointers[(int) RID_REGISTER]
6985                || value == ridpointers[(int) RID_INLINE]
6986                || value == ridpointers[(int) RID_VIRTUAL]
6987                || value == ridpointers[(int) RID_CONST]
6988                || value == ridpointers[(int) RID_VOLATILE]
6989                || value == ridpointers[(int) RID_EXPLICIT])
6990         ob_modifier = value;
6991     }
6992
6993   if (found_type > 1)
6994     error ("multiple types in one declaration");
6995
6996   if (t == NULL_TREE && ! saw_friend)
6997     pedwarn ("declaration does not declare anything");
6998
6999   /* Check for an anonymous union.  We're careful
7000      accessing TYPE_IDENTIFIER because some built-in types, like
7001      pointer-to-member types, do not have TYPE_NAME.  */
7002   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7003            && TYPE_NAME (t)
7004            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7005     {
7006       /* Anonymous unions are objects, so they can have specifiers.  */;
7007       SET_ANON_AGGR_TYPE_P (t);
7008
7009       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7010         pedwarn ("ISO C++ prohibits anonymous structs");
7011     }
7012
7013   else if (ob_modifier)
7014     {
7015       if (ob_modifier == ridpointers[(int) RID_INLINE]
7016           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7017         cp_error ("`%D' can only be specified for functions", ob_modifier);
7018       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7019         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7020       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7021         cp_error ("`%D' can only be specified for constructors",
7022                   ob_modifier);
7023       else
7024         cp_error ("`%D' can only be specified for objects and functions",
7025                   ob_modifier);
7026     }
7027
7028   return t;
7029 }
7030
7031 /* Called when a declaration is seen that contains no names to declare.
7032    If its type is a reference to a structure, union or enum inherited
7033    from a containing scope, shadow that tag name for the current scope
7034    with a forward reference.
7035    If its type defines a new named structure or union
7036    or defines an enum, it is valid but we need not do anything here.
7037    Otherwise, it is an error.
7038
7039    C++: may have to grok the declspecs to learn about static,
7040    complain for anonymous unions.  */
7041
7042 void
7043 shadow_tag (declspecs)
7044      tree declspecs;
7045 {
7046   tree t = check_tag_decl (declspecs);
7047
7048   if (t)
7049     maybe_process_partial_specialization (t);
7050
7051   /* This is where the variables in an anonymous union are
7052      declared.  An anonymous union declaration looks like:
7053      union { ... } ;
7054      because there is no declarator after the union, the parser
7055      sends that declaration here.  */
7056   if (t && ANON_AGGR_TYPE_P (t))
7057     {
7058       fixup_anonymous_aggr (t);
7059
7060       if (TYPE_FIELDS (t))
7061         {
7062           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7063                                       NULL_TREE);
7064           finish_anon_union (decl);
7065         }
7066     }
7067 }
7068 \f
7069 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7070
7071 tree
7072 groktypename (typename)
7073      tree typename;
7074 {
7075   if (TREE_CODE (typename) != TREE_LIST)
7076     return typename;
7077   return grokdeclarator (TREE_VALUE (typename),
7078                          TREE_PURPOSE (typename),
7079                          TYPENAME, 0, NULL_TREE);
7080 }
7081
7082 /* Decode a declarator in an ordinary declaration or data definition.
7083    This is called as soon as the type information and variable name
7084    have been parsed, before parsing the initializer if any.
7085    Here we create the ..._DECL node, fill in its type,
7086    and put it on the list of decls for the current context.
7087    The ..._DECL node is returned as the value.
7088
7089    Exception: for arrays where the length is not specified,
7090    the type is left null, to be filled in by `cp_finish_decl'.
7091
7092    Function definitions do not come here; they go to start_function
7093    instead.  However, external and forward declarations of functions
7094    do go through here.  Structure field declarations are done by
7095    grokfield and not through here.  */
7096
7097 tree
7098 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7099      tree declarator, declspecs;
7100      int initialized;
7101      tree attributes, prefix_attributes;
7102 {
7103   register tree decl;
7104   register tree type, tem;
7105   tree context;
7106   extern int have_extern_spec;
7107   extern int used_extern_spec;
7108   tree attrlist;
7109
7110 #if 0
7111   /* See code below that used this.  */
7112   int init_written = initialized;
7113 #endif
7114
7115   /* This should only be done once on the top most decl.  */
7116   if (have_extern_spec && !used_extern_spec)
7117     {
7118       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7119                                   declspecs);
7120       used_extern_spec = 1;
7121     }
7122
7123   if (attributes || prefix_attributes)
7124     attrlist = build_tree_list (attributes, prefix_attributes);
7125   else
7126     attrlist = NULL_TREE;
7127
7128   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7129                          attrlist);
7130
7131   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7132     return NULL_TREE;
7133
7134   type = TREE_TYPE (decl);
7135
7136   if (type == error_mark_node)
7137     return NULL_TREE;
7138
7139   context = DECL_CONTEXT (decl);
7140
7141   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7142       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7143     {
7144       /* When parsing the initializer, lookup should use the object's
7145          namespace. */
7146       push_decl_namespace (context);
7147     }
7148
7149   /* We are only interested in class contexts, later. */
7150   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7151     context = NULL_TREE;
7152
7153   if (initialized)
7154     /* Is it valid for this decl to have an initializer at all?
7155        If not, set INITIALIZED to zero, which will indirectly
7156        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7157     switch (TREE_CODE (decl))
7158       {
7159       case TYPE_DECL:
7160         /* typedef foo = bar  means give foo the same type as bar.
7161            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7162            Any other case of an initialization in a TYPE_DECL is an error.  */
7163         if (pedantic || list_length (declspecs) > 1)
7164           {
7165             cp_error ("typedef `%D' is initialized", decl);
7166             initialized = 0;
7167           }
7168         break;
7169
7170       case FUNCTION_DECL:
7171         cp_error ("function `%#D' is initialized like a variable", decl);
7172         initialized = 0;
7173         break;
7174
7175       default:
7176         break;
7177       }
7178
7179   if (initialized)
7180     {
7181       if (! toplevel_bindings_p ()
7182           && DECL_EXTERNAL (decl))
7183         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7184                     decl);
7185       DECL_EXTERNAL (decl) = 0;
7186       if (toplevel_bindings_p ())
7187         TREE_STATIC (decl) = 1;
7188
7189       /* Tell `pushdecl' this is an initialized decl
7190          even though we don't yet have the initializer expression.
7191          Also tell `cp_finish_decl' it may store the real initializer.  */
7192       DECL_INITIAL (decl) = error_mark_node;
7193     }
7194
7195 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7196   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7197 #endif
7198
7199   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7200   cplus_decl_attributes (decl, attributes, prefix_attributes);
7201
7202   if (context && COMPLETE_TYPE_P (complete_type (context)))
7203     {
7204       push_nested_class (context, 2);
7205
7206       if (TREE_CODE (decl) == VAR_DECL)
7207         {
7208           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7209           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7210             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7211           else
7212             {
7213               if (DECL_CONTEXT (field) != context)
7214                 {
7215                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7216                               DECL_CONTEXT (field), DECL_NAME (decl),
7217                               context, DECL_NAME (decl));
7218                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7219                 }
7220               /* Static data member are tricky; an in-class initialization
7221                  still doesn't provide a definition, so the in-class
7222                  declaration will have DECL_EXTERNAL set, but will have an
7223                  initialization.  Thus, duplicate_decls won't warn
7224                  about this situation, and so we check here.  */
7225               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7226                 cp_error ("duplicate initialization of %D", decl);
7227               if (duplicate_decls (decl, field))
7228                 decl = field;
7229             }
7230         }
7231       else
7232         {
7233           tree field = check_classfn (context, decl);
7234           if (field && duplicate_decls (decl, field))
7235             decl = field;
7236         }
7237
7238       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7239       DECL_IN_AGGR_P (decl) = 0;
7240       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7241           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7242         {
7243           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7244           /* [temp.expl.spec] An explicit specialization of a static data
7245              member of a template is a definition if the declaration
7246              includes an initializer; otherwise, it is a declaration.
7247
7248              We check for processing_specialization so this only applies
7249              to the new specialization syntax.  */
7250           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7251             DECL_EXTERNAL (decl) = 1;
7252         }
7253
7254       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7255         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7256                     decl);
7257     }
7258
7259   /* Enter this declaration into the symbol table.  */
7260   tem = maybe_push_decl (decl);
7261
7262   if (processing_template_decl)
7263     tem = push_template_decl (tem);
7264
7265 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7266   /* Tell the back-end to use or not use .common as appropriate.  If we say
7267      -fconserve-space, we want this to save .data space, at the expense of
7268      wrong semantics.  If we say -fno-conserve-space, we want this to
7269      produce errors about redefs; to do this we force variables into the
7270      data segment.  */
7271   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7272 #endif
7273
7274   if (! processing_template_decl)
7275     start_decl_1 (tem);
7276
7277   return tem;
7278 }
7279
7280 void
7281 start_decl_1 (decl)
7282      tree decl;
7283 {
7284   tree type = TREE_TYPE (decl);
7285   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7286
7287   if (type == error_mark_node)
7288     return;
7289
7290   /* If this type of object needs a cleanup, but we're not allowed to
7291      add any more objects with cleanups to the current scope, create a
7292      new binding level.  */
7293   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7294       && current_binding_level->more_cleanups_ok == 0)
7295     {
7296       keep_next_level (2);
7297       pushlevel (1);
7298       clear_last_expr ();
7299       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7300     }
7301
7302   if (initialized)
7303     /* Is it valid for this decl to have an initializer at all?
7304        If not, set INITIALIZED to zero, which will indirectly
7305        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7306     {
7307       /* Don't allow initializations for incomplete types except for
7308          arrays which might be completed by the initialization.  */
7309       if (COMPLETE_TYPE_P (complete_type (type)))
7310         ;                       /* A complete type is ok.  */
7311       else if (TREE_CODE (type) != ARRAY_TYPE)
7312         {
7313           cp_error ("variable `%#D' has initializer but incomplete type",
7314                     decl);
7315           initialized = 0;
7316           type = TREE_TYPE (decl) = error_mark_node;
7317         }
7318       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7319         {
7320           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7321             cp_error ("elements of array `%#D' have incomplete type", decl);
7322           /* else we already gave an error in start_decl.  */
7323           initialized = 0;
7324         }
7325     }
7326
7327   if (!initialized
7328       && TREE_CODE (decl) != TYPE_DECL
7329       && TREE_CODE (decl) != TEMPLATE_DECL
7330       && type != error_mark_node
7331       && IS_AGGR_TYPE (type)
7332       && ! DECL_EXTERNAL (decl))
7333     {
7334       if ((! processing_template_decl || ! uses_template_parms (type))
7335           && !COMPLETE_TYPE_P (complete_type (type)))
7336         {
7337           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7338                  decl);
7339           /* Change the type so that assemble_variable will give
7340              DECL an rtl we can live with: (mem (const_int 0)).  */
7341           type = TREE_TYPE (decl) = error_mark_node;
7342         }
7343       else
7344         {
7345           /* If any base type in the hierarchy of TYPE needs a constructor,
7346              then we set initialized to 1.  This way any nodes which are
7347              created for the purposes of initializing this aggregate
7348              will live as long as it does.  This is necessary for global
7349              aggregates which do not have their initializers processed until
7350              the end of the file.  */
7351           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7352         }
7353     }
7354
7355   if (! initialized)
7356     DECL_INITIAL (decl) = NULL_TREE;
7357 }
7358
7359 /* Handle initialization of references.
7360    These three arguments are from `cp_finish_decl', and have the
7361    same meaning here that they do there.
7362
7363    Quotes on semantics can be found in ARM 8.4.3.  */
7364
7365 static void
7366 grok_reference_init (decl, type, init)
7367      tree decl, type, init;
7368 {
7369   tree tmp;
7370
7371   if (init == NULL_TREE)
7372     {
7373       if ((DECL_LANG_SPECIFIC (decl) == 0
7374            || DECL_IN_AGGR_P (decl) == 0)
7375           && ! DECL_THIS_EXTERN (decl))
7376         cp_error ("`%D' declared as reference but not initialized", decl);
7377       return;
7378     }
7379
7380   if (init == error_mark_node)
7381     return;
7382
7383   if (TREE_CODE (init) == CONSTRUCTOR)
7384     {
7385       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7386       return;
7387     }
7388
7389   if (TREE_CODE (init) == TREE_LIST)
7390     init = build_compound_expr (init);
7391
7392   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7393     init = convert_from_reference (init);
7394
7395   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7396       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7397     {
7398       /* Note: default conversion is only called in very special cases.  */
7399       init = default_conversion (init);
7400     }
7401
7402   /* Convert INIT to the reference type TYPE.  This may involve the
7403      creation of a temporary, whose lifetime must be the same as that
7404      of the reference.  If so, a DECL_STMT for the temporary will be
7405      added just after the DECL_STMT for DECL.  That's why we don't set
7406      DECL_INITIAL for local references (instead assigning to them
7407      explicitly); we need to allow the temporary to be initialized
7408      first.  */
7409   tmp = convert_to_reference
7410     (type, init, CONV_IMPLICIT,
7411      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7412      decl);
7413
7414   if (tmp == error_mark_node)
7415     return;
7416   else if (tmp != NULL_TREE)
7417     {
7418       init = tmp;
7419       tmp = save_expr (tmp);
7420       if (building_stmt_tree ())
7421         {
7422           /* Initialize the declaration.  */
7423           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7424           finish_expr_stmt (tmp);
7425         }
7426       else
7427         DECL_INITIAL (decl) = tmp;
7428     }
7429   else
7430     {
7431       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7432       return;
7433     }
7434
7435   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7436     {
7437       expand_static_init (decl, DECL_INITIAL (decl));
7438       DECL_INITIAL (decl) = NULL_TREE;
7439     }
7440   return;
7441 }
7442
7443 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7444    mucking with forces it does not comprehend (i.e. initialization with a
7445    constructor).  If we are at global scope and won't go into COMMON, fill
7446    it in with a dummy CONSTRUCTOR to force the variable into .data;
7447    otherwise we can use error_mark_node.  */
7448
7449 static tree
7450 obscure_complex_init (decl, init)
7451      tree decl, init;
7452 {
7453   if (! flag_no_inline && TREE_STATIC (decl))
7454     {
7455       if (extract_init (decl, init))
7456         return NULL_TREE;
7457     }
7458
7459 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7460   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7461     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7462                                  NULL_TREE);
7463   else
7464 #endif
7465     DECL_INITIAL (decl) = error_mark_node;
7466
7467   return init;
7468 }
7469
7470 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7471    array until we finish parsing the initializer.  If that's the
7472    situation we're in, update DECL accordingly.  */
7473
7474 static void
7475 maybe_deduce_size_from_array_init (decl, init)
7476      tree decl;
7477      tree init;
7478 {
7479   tree type = TREE_TYPE (decl);
7480
7481   if (TREE_CODE (type) == ARRAY_TYPE
7482       && TYPE_DOMAIN (type) == NULL_TREE
7483       && TREE_CODE (decl) != TYPE_DECL)
7484     {
7485       int do_default
7486         = (TREE_STATIC (decl)
7487            /* Even if pedantic, an external linkage array
7488               may have incomplete type at first.  */
7489            ? pedantic && ! DECL_EXTERNAL (decl)
7490            : !DECL_EXTERNAL (decl));
7491       tree initializer = init ? init : DECL_INITIAL (decl);
7492       int failure = complete_array_type (type, initializer, do_default);
7493
7494       if (failure == 1)
7495         cp_error ("initializer fails to determine size of `%D'", decl);
7496
7497       if (failure == 2)
7498         {
7499           if (do_default)
7500             cp_error ("array size missing in `%D'", decl);
7501           /* If a `static' var's size isn't known, make it extern as
7502              well as static, so it does not get allocated.  If it's not
7503              `static', then don't mark it extern; finish_incomplete_decl
7504              will give it a default size and it will get allocated.  */
7505           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7506             DECL_EXTERNAL (decl) = 1;
7507         }
7508
7509       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7510           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7511                               integer_zero_node))
7512         cp_error ("zero-size array `%D'", decl);
7513
7514       layout_decl (decl, 0);
7515     }
7516 }
7517
7518 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7519    any appropriate error messages regarding the layout.  */
7520
7521 static void
7522 layout_var_decl (decl)
7523      tree decl;
7524 {
7525   tree type = TREE_TYPE (decl);
7526 #if 0
7527   tree ttype = target_type (type);
7528 #endif
7529
7530   /* If we haven't already layed out this declaration, do so now.
7531      Note that we must not call complete type for an external object
7532      because it's type might involve templates that we are not
7533      supposed to isntantiate yet.  (And it's perfectly legal to say
7534      `extern X x' for some incomplete type `X'.)  */
7535   if (!DECL_EXTERNAL (decl))
7536     complete_type (type);
7537   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7538     layout_decl (decl, 0);
7539
7540   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7541     {
7542       /* An automatic variable with an incomplete type: that is an error.
7543          Don't talk about array types here, since we took care of that
7544          message in grokdeclarator.  */
7545       cp_error ("storage size of `%D' isn't known", decl);
7546       TREE_TYPE (decl) = error_mark_node;
7547     }
7548 #if 0
7549   /* Keep this code around in case we later want to control debug info
7550      based on whether a type is "used".  (jason 1999-11-11) */
7551
7552   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7553     /* Let debugger know it should output info for this type.  */
7554     note_debug_info_needed (ttype);
7555
7556   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7557     note_debug_info_needed (DECL_CONTEXT (decl));
7558 #endif
7559
7560   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7561       && DECL_SIZE (decl) != NULL_TREE
7562       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7563     {
7564       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7565         constant_expression_warning (DECL_SIZE (decl));
7566       else
7567         cp_error ("storage size of `%D' isn't constant", decl);
7568     }
7569 }
7570
7571 /* If a local static variable is declared in an inline function, or if
7572    we have a weak definition, we must endeavor to create only one
7573    instance of the variable at link-time.  */
7574
7575 static void
7576 maybe_commonize_var (decl)
7577      tree decl;
7578 {
7579   /* Static data in a function with comdat linkage also has comdat
7580      linkage.  */
7581   if (TREE_STATIC (decl)
7582       /* Don't mess with __FUNCTION__.  */
7583       && ! DECL_ARTIFICIAL (decl)
7584       && current_function_decl
7585       && DECL_CONTEXT (decl) == current_function_decl
7586       && (DECL_THIS_INLINE (current_function_decl)
7587           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7588       && TREE_PUBLIC (current_function_decl))
7589     {
7590       /* Rather than try to get this right with inlining, we suppress
7591          inlining of such functions.  */
7592       current_function_cannot_inline
7593         = "function with static variable cannot be inline";
7594
7595       /* If flag_weak, we don't need to mess with this, as we can just
7596          make the function weak, and let it refer to its unique local
7597          copy.  This works because we don't allow the function to be
7598          inlined.  */
7599       if (! flag_weak)
7600         {
7601           if (DECL_INTERFACE_KNOWN (current_function_decl))
7602             {
7603               TREE_PUBLIC (decl) = 1;
7604               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7605             }
7606           else if (DECL_INITIAL (decl) == NULL_TREE
7607                    || DECL_INITIAL (decl) == error_mark_node)
7608             {
7609               TREE_PUBLIC (decl) = 1;
7610               DECL_COMMON (decl) = 1;
7611             }
7612           /* else we lose. We can only do this if we can use common,
7613              which we can't if it has been initialized.  */
7614
7615           if (TREE_PUBLIC (decl))
7616             DECL_ASSEMBLER_NAME (decl)
7617               = build_static_name (current_function_decl, DECL_NAME (decl));
7618           else
7619             {
7620               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7621               cp_warning_at ("  you can work around this by removing the initializer", decl);
7622             }
7623         }
7624     }
7625   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7626     /* Set it up again; we might have set DECL_INITIAL since the last
7627        time.  */
7628     comdat_linkage (decl);
7629 }
7630
7631 /* Issue an error message if DECL is an uninitialized const variable.  */
7632
7633 static void
7634 check_for_uninitialized_const_var (decl)
7635      tree decl;
7636 {
7637   tree type = TREE_TYPE (decl);
7638
7639   /* ``Unless explicitly declared extern, a const object does not have
7640      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7641      7.1.6 */
7642   if (TREE_CODE (decl) == VAR_DECL
7643       && TREE_CODE (type) != REFERENCE_TYPE
7644       && CP_TYPE_CONST_P (type)
7645       && !TYPE_NEEDS_CONSTRUCTING (type)
7646       && !DECL_INITIAL (decl))
7647     cp_error ("uninitialized const `%D'", decl);
7648 }
7649
7650 /* Verify INIT (the initializer for DECL), and record the
7651    initialization in DECL_INITIAL, if appropriate.  Returns a new
7652    value for INIT.  */
7653
7654 static tree
7655 check_initializer (decl, init)
7656      tree decl;
7657      tree init;
7658 {
7659   tree type;
7660
7661   if (TREE_CODE (decl) == FIELD_DECL)
7662     return init;
7663
7664   type = TREE_TYPE (decl);
7665
7666   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7667   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7668     init = NULL_TREE;
7669
7670   /* Check the initializer.  */
7671   if (init)
7672     {
7673       /* Things that are going to be initialized need to have complete
7674          type.  */
7675       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7676
7677       if (type == error_mark_node)
7678         /* We will have already complained.  */
7679         init = NULL_TREE;
7680       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7681         {
7682           cp_error ("variable-sized object `%D' may not be initialized", decl);
7683           init = NULL_TREE;
7684         }
7685       else if (TREE_CODE (type) == ARRAY_TYPE
7686                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7687         {
7688           cp_error ("elements of array `%#D' have incomplete type", decl);
7689           init = NULL_TREE;
7690         }
7691       else if (!COMPLETE_TYPE_P (type))
7692         {
7693           cp_error ("`%D' has incomplete type", decl);
7694           TREE_TYPE (decl) = error_mark_node;
7695           init = NULL_TREE;
7696         }
7697     }
7698
7699   if (TREE_CODE (decl) == CONST_DECL)
7700     {
7701       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7702
7703       DECL_INITIAL (decl) = init;
7704
7705       /* This will keep us from needing to worry about our obstacks.  */
7706       my_friendly_assert (init != NULL_TREE, 149);
7707       init = NULL_TREE;
7708     }
7709   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7710     {
7711       if (TREE_STATIC (decl))
7712         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7713       grok_reference_init (decl, type, init);
7714       init = NULL_TREE;
7715     }
7716   else if (init)
7717     {
7718       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7719         {
7720           if (TREE_CODE (type) == ARRAY_TYPE)
7721             init = digest_init (type, init, (tree *) 0);
7722           else if (TREE_CODE (init) == CONSTRUCTOR
7723                    && TREE_HAS_CONSTRUCTOR (init))
7724             {
7725               if (TYPE_NON_AGGREGATE_CLASS (type))
7726                 {
7727                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7728                             decl);
7729                   init = error_mark_node;
7730                 }
7731               else
7732                 goto dont_use_constructor;
7733             }
7734         }
7735       else
7736         {
7737         dont_use_constructor:
7738           if (TREE_CODE (init) != TREE_VEC)
7739             init = store_init_value (decl, init);
7740         }
7741
7742       if (init)
7743         /* We must hide the initializer so that expand_decl
7744            won't try to do something it does not understand.  */
7745         init = obscure_complex_init (decl, init);
7746     }
7747   else if (DECL_EXTERNAL (decl))
7748     ;
7749   else if (TYPE_P (type)
7750            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7751     {
7752       tree core_type = strip_array_types (type);
7753
7754       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7755         {
7756           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7757             cp_error ("structure `%D' with uninitialized const members", decl);
7758           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7759             cp_error ("structure `%D' with uninitialized reference members",
7760                       decl);
7761         }
7762
7763       check_for_uninitialized_const_var (decl);
7764
7765       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7766         init = obscure_complex_init (decl, NULL_TREE);
7767
7768     }
7769   else
7770     check_for_uninitialized_const_var (decl);
7771
7772   return init;
7773 }
7774
7775 /* If DECL is not a local variable, give it RTL.  */
7776
7777 static void
7778 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7779      tree decl;
7780      tree init;
7781      const char *asmspec;
7782 {
7783   int toplev = toplevel_bindings_p ();
7784   int defer_p;
7785
7786   /* Handle non-variables up front.  */
7787   if (TREE_CODE (decl) != VAR_DECL)
7788     {
7789       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7790       return;
7791     }
7792
7793   /* If we see a class member here, it should be a static data
7794      member.  */
7795   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7796     {
7797       my_friendly_assert (TREE_STATIC (decl), 19990828);
7798       /* An in-class declaration of a static data member should be
7799          external; it is only a declaration, and not a definition.  */
7800       if (init == NULL_TREE)
7801         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7802     }
7803
7804   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7805   if (asmspec)
7806     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7807
7808   /* We don't create any RTL for local variables.  */
7809   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7810     return;
7811
7812   /* We defer emission of local statics until the corresponding
7813      DECL_STMT is expanded.  */
7814   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7815
7816   /* We try to defer namespace-scope static constants so that they are
7817      not emitted into the object file unncessarily.  */
7818   if (!DECL_VIRTUAL_P (decl)
7819       && TREE_READONLY (decl)
7820       && DECL_INITIAL (decl) != NULL_TREE
7821       && DECL_INITIAL (decl) != error_mark_node
7822       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7823       && toplev
7824       && !TREE_PUBLIC (decl))
7825     {
7826       /* Fool with the linkage according to #pragma interface.  */
7827       if (!interface_unknown)
7828         {
7829           TREE_PUBLIC (decl) = 1;
7830           DECL_EXTERNAL (decl) = interface_only;
7831         }
7832
7833       defer_p = 1;
7834     }
7835
7836   /* If we're deferring the variable, just make RTL.  Do not actually
7837      emit the variable.  */
7838   if (defer_p)
7839     make_decl_rtl (decl, asmspec, toplev);
7840   /* If we're not deferring, go ahead and assemble the variable.  */
7841   else
7842     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7843 }
7844
7845 /* The old ARM scoping rules injected variables declared in the
7846    initialization statement of a for-statement into the surrounding
7847    scope.  We support this usage, in order to be backward-compatible.
7848    DECL is a just-declared VAR_DECL; if necessary inject its
7849    declaration into the surrounding scope.  */
7850
7851 void
7852 maybe_inject_for_scope_var (decl)
7853      tree decl;
7854 {
7855   if (!DECL_NAME (decl))
7856     return;
7857
7858   if (current_binding_level->is_for_scope)
7859     {
7860       struct binding_level *outer
7861         = current_binding_level->level_chain;
7862
7863       /* Check to see if the same name is already bound at the outer
7864          level, either because it was directly declared, or because a
7865          dead for-decl got preserved.  In either case, the code would
7866          not have been valid under the ARM scope rules, so clear
7867          is_for_scope for the current_binding_level.
7868
7869          Otherwise, we need to preserve the temp slot for decl to last
7870          into the outer binding level.  */
7871
7872       tree outer_binding
7873         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7874
7875       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7876           && (TREE_CODE (BINDING_VALUE (outer_binding))
7877               == VAR_DECL)
7878           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7879         {
7880           BINDING_VALUE (outer_binding)
7881             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7882           current_binding_level->is_for_scope = 0;
7883         }
7884       else if (DECL_IN_MEMORY_P (decl))
7885         preserve_temp_slots (DECL_RTL (decl));
7886     }
7887 }
7888
7889 /* Generate code to initialize DECL (a local variable).  */
7890
7891 void
7892 initialize_local_var (decl, init, flags)
7893      tree decl;
7894      tree init;
7895      int flags;
7896 {
7897   tree type = TREE_TYPE (decl);
7898
7899   /* If the type is bogus, don't bother initializing the variable.  */
7900   if (type == error_mark_node)
7901     return;
7902
7903   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7904     {
7905       /* If we used it already as memory, it must stay in memory.  */
7906       DECL_INITIAL (decl) = NULL_TREE;
7907       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7908     }
7909
7910   /* Local statics are handled differently from ordinary automatic
7911      variables.  */
7912   if (TREE_STATIC (decl))
7913     {
7914       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7915           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7916         expand_static_init (decl, init);
7917       return;
7918     }
7919
7920   if (DECL_SIZE (decl) && type != error_mark_node)
7921     {
7922       int already_used;
7923
7924       /* Compute and store the initial value.  */
7925       already_used = TREE_USED (decl) || TREE_USED (type);
7926
7927       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7928         {
7929           int saved_stmts_are_full_exprs_p;
7930
7931           emit_line_note (DECL_SOURCE_FILE (decl),
7932                           DECL_SOURCE_LINE (decl));
7933           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7934           current_stmt_tree->stmts_are_full_exprs_p = 1;
7935           if (building_stmt_tree ())
7936             finish_expr_stmt (build_aggr_init (decl, init, flags));
7937           else
7938             genrtl_expr_stmt (build_aggr_init (decl, init, flags));
7939           current_stmt_tree->stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7940         }
7941
7942       /* Set this to 0 so we can tell whether an aggregate which was
7943          initialized was ever used.  Don't do this if it has a
7944          destructor, so we don't complain about the 'resource
7945          allocation is initialization' idiom.  Now set
7946          attribute((unused)) on types so decls of that type will be
7947          marked used. (see TREE_USED, above.)  */
7948       if (TYPE_NEEDS_CONSTRUCTING (type)
7949           && ! already_used
7950           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7951           && DECL_NAME (decl))
7952         TREE_USED (decl) = 0;
7953       else if (already_used)
7954         TREE_USED (decl) = 1;
7955     }
7956 }
7957
7958 /* Generate code to destroy DECL (a local variable).  */
7959
7960 static void
7961 destroy_local_var (decl)
7962      tree decl;
7963 {
7964   tree type = TREE_TYPE (decl);
7965   tree cleanup;
7966
7967   /* Only variables get cleaned up.  */
7968   if (TREE_CODE (decl) != VAR_DECL)
7969     return;
7970
7971   /* And only things with destructors need cleaning up.  */
7972   if (type == error_mark_node
7973       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7974     return;
7975
7976   if (TREE_CODE (decl) == VAR_DECL &&
7977       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7978     /* We don't clean up things that aren't defined in this
7979        translation unit, or that need a static cleanup.  The latter
7980        are handled by finish_file.  */
7981     return;
7982
7983   /* Compute the cleanup.  */
7984   cleanup = maybe_build_cleanup (decl);
7985
7986   /* Record the cleanup required for this declaration.  */
7987   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7988       && cleanup)
7989     finish_decl_cleanup (decl, cleanup);
7990 }
7991
7992 /* Finish processing of a declaration;
7993    install its line number and initial value.
7994    If the length of an array type is not known before,
7995    it must be determined now, from the initial value, or it is an error.
7996
7997    INIT holds the value of an initializer that should be allowed to escape
7998    the normal rules.
7999
8000    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8001    if the (init) syntax was used.  */
8002
8003 void
8004 cp_finish_decl (decl, init, asmspec_tree, flags)
8005      tree decl, init;
8006      tree asmspec_tree;
8007      int flags;
8008 {
8009   register tree type;
8010   tree ttype = NULL_TREE;
8011   const char *asmspec = NULL;
8012   int was_readonly = 0;
8013
8014   if (! decl)
8015     {
8016       if (init)
8017         error ("assignment (not initialization) in declaration");
8018       return;
8019     }
8020
8021   /* If a name was specified, get the string.  */
8022   if (asmspec_tree)
8023       asmspec = TREE_STRING_POINTER (asmspec_tree);
8024
8025   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8026     {
8027       cp_error ("cannot initialize `%D' to namespace `%D'",
8028                 decl, init);
8029       init = NULL_TREE;
8030     }
8031
8032   if (current_class_type
8033       && CP_DECL_CONTEXT (decl) == current_class_type
8034       && TYPE_BEING_DEFINED (current_class_type)
8035       && (DECL_INITIAL (decl) || init))
8036     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8037
8038   if (TREE_CODE (decl) == VAR_DECL
8039       && DECL_CONTEXT (decl)
8040       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8041       && DECL_CONTEXT (decl) != current_namespace
8042       && init)
8043     {
8044       /* Leave the namespace of the object. */
8045       pop_decl_namespace ();
8046     }
8047
8048   type = TREE_TYPE (decl);
8049
8050   if (type == error_mark_node)
8051     return;
8052
8053   /* Add this declaration to the statement-tree.  */
8054   if (building_stmt_tree () && at_function_scope_p ())
8055     add_decl_stmt (decl);
8056
8057   if (TYPE_HAS_MUTABLE_P (type))
8058     TREE_READONLY (decl) = 0;
8059
8060   if (processing_template_decl)
8061     {
8062       if (init && DECL_INITIAL (decl))
8063         DECL_INITIAL (decl) = init;
8064       goto finish_end0;
8065     }
8066
8067   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8068   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8069
8070   /* Take care of TYPE_DECLs up front.  */
8071   if (TREE_CODE (decl) == TYPE_DECL)
8072     {
8073       if (init && DECL_INITIAL (decl))
8074         {
8075           /* typedef foo = bar; store the type of bar as the type of foo.  */
8076           TREE_TYPE (decl) = type = TREE_TYPE (init);
8077           DECL_INITIAL (decl) = init = NULL_TREE;
8078         }
8079       if (type != error_mark_node
8080           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8081         {
8082           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8083             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8084           set_identifier_type_value (DECL_NAME (decl), type);
8085           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8086         }
8087       GNU_xref_decl (current_function_decl, decl);
8088
8089       /* If we have installed this as the canonical typedef for this
8090          type, and that type has not been defined yet, delay emitting
8091          the debug information for it, as we will emit it later.  */
8092       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8093           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8094         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8095
8096       rest_of_decl_compilation (decl, NULL_PTR,
8097                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8098       goto finish_end;
8099     }
8100
8101   if (TREE_CODE (decl) != FUNCTION_DECL)
8102     ttype = target_type (type);
8103
8104   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8105       && TYPE_NEEDS_CONSTRUCTING (type))
8106     {
8107       /* Currently, GNU C++ puts constants in text space, making them
8108          impossible to initialize.  In the future, one would hope for
8109          an operating system which understood the difference between
8110          initialization and the running of a program.  */
8111       was_readonly = 1;
8112       TREE_READONLY (decl) = 0;
8113     }
8114
8115   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8116     {
8117       /* This must override the asm specifier which was placed by
8118          grokclassfn.  Lay this out fresh.  */
8119       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8120       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8121       make_decl_rtl (decl, asmspec, 0);
8122     }
8123
8124   /* Deduce size of array from initialization, if not already known.  */
8125   maybe_deduce_size_from_array_init (decl, init);
8126   init = check_initializer (decl, init);
8127
8128   GNU_xref_decl (current_function_decl, decl);
8129
8130   if (TREE_CODE (decl) == VAR_DECL)
8131     layout_var_decl (decl);
8132
8133   /* Output the assembler code and/or RTL code for variables and functions,
8134      unless the type is an undefined structure or union.
8135      If not, it will get done when the type is completed.  */
8136   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8137       || TREE_CODE (decl) == RESULT_DECL)
8138     {
8139       if (TREE_CODE (decl) == VAR_DECL)
8140         maybe_commonize_var (decl);
8141
8142       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8143
8144       if (TREE_CODE (type) == FUNCTION_TYPE
8145           || TREE_CODE (type) == METHOD_TYPE)
8146         abstract_virtuals_error (decl,
8147                                  strip_array_types (TREE_TYPE (type)));
8148       else
8149         abstract_virtuals_error (decl, strip_array_types (type));
8150
8151       if (TREE_CODE (decl) == FUNCTION_DECL)
8152         ;
8153       else if (DECL_EXTERNAL (decl)
8154                && ! (DECL_LANG_SPECIFIC (decl)
8155                      && DECL_NOT_REALLY_EXTERN (decl)))
8156         {
8157           if (init)
8158             DECL_INITIAL (decl) = init;
8159         }
8160       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8161         {
8162           /* This is a local declaration.  */
8163           if (doing_semantic_analysis_p ())
8164             maybe_inject_for_scope_var (decl);
8165           /* Initialize the local variable.  But, if we're building a
8166              statement-tree, we'll do the initialization when we
8167              expand the tree.  */
8168           if (processing_template_decl)
8169             {
8170               if (init || DECL_INITIAL (decl) == error_mark_node)
8171                 DECL_INITIAL (decl) = init;
8172             }
8173           else
8174             {
8175               /* If we're not building RTL, then we need to do so
8176                  now.  */
8177               if (!building_stmt_tree ())
8178                 emit_local_var (decl);
8179               /* Initialize the variable.  */
8180               initialize_local_var (decl, init, flags);
8181               /* Clean up the variable.  */
8182               destroy_local_var (decl);
8183             }
8184         }
8185       else if (TREE_STATIC (decl) && type != error_mark_node)
8186         {
8187           /* Cleanups for static variables are handled by `finish_file'.  */
8188           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8189               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8190             expand_static_init (decl, init);
8191         }
8192     finish_end0:
8193
8194       /* Undo call to `pushclass' that was done in `start_decl'
8195          due to initialization of qualified member variable.
8196          I.e., Foo::x = 10;  */
8197       {
8198         tree context = CP_DECL_CONTEXT (decl);
8199         if (context
8200             && TYPE_P (context)
8201             && (TREE_CODE (decl) == VAR_DECL
8202                 /* We also have a pushclass done that we need to undo here
8203                    if we're at top level and declare a method.  */
8204                 || TREE_CODE (decl) == FUNCTION_DECL)
8205             /* If size hasn't been set, we're still defining it,
8206                and therefore inside the class body; don't pop
8207                the binding level..  */
8208             && COMPLETE_TYPE_P (context)
8209             && context == current_class_type)
8210           pop_nested_class ();
8211       }
8212     }
8213
8214  finish_end:
8215
8216   if (was_readonly)
8217     TREE_READONLY (decl) = 1;
8218 }
8219
8220 /* This is here for a midend callback from c-common.c */
8221
8222 void
8223 finish_decl (decl, init, asmspec_tree)
8224      tree decl, init;
8225      tree asmspec_tree;
8226 {
8227   cp_finish_decl (decl, init, asmspec_tree, 0);
8228 }
8229
8230 /* Returns a declaration for a VAR_DECL as if:
8231
8232      extern "C" TYPE NAME;
8233
8234    had been seen.  Used to create compiler-generated global
8235    variables.  */
8236
8237 tree
8238 declare_global_var (name, type)
8239      tree name;
8240      tree type;
8241 {
8242   tree decl;
8243
8244   push_to_top_level ();
8245   decl = build_decl (VAR_DECL, name, type);
8246   TREE_PUBLIC (decl) = 1;
8247   DECL_EXTERNAL (decl) = 1;
8248   DECL_ARTIFICIAL (decl) = 1;
8249   pushdecl (decl);
8250   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8251   pop_from_top_level ();
8252
8253   return decl;
8254 }
8255
8256 /* Returns a pointer to the `atexit' function.  Note that if
8257    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8258    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8259
8260 static tree
8261 get_atexit_node ()
8262 {
8263   tree atexit_fndecl;
8264   tree arg_types;
8265   tree fn_type;
8266   tree fn_ptr_type;
8267   const char *name;
8268
8269   if (atexit_node)
8270     return atexit_node;
8271
8272   if (flag_use_cxa_atexit)
8273     {
8274       /* The declaration for `__cxa_atexit' is:
8275
8276            int __cxa_atexit (void (*)(void *), void *, void *)
8277
8278          We build up the argument types and then then function type
8279          itself.  */
8280
8281       /* First, build the pointer-to-function type for the first
8282          argument.  */
8283       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8284       fn_type = build_function_type (void_type_node, arg_types);
8285       fn_ptr_type = build_pointer_type (fn_type);
8286       /* Then, build the rest of the argument types.  */
8287       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8288       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8289       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8290       /* And the final __cxa_atexit type.  */
8291       fn_type = build_function_type (integer_type_node, arg_types);
8292       fn_ptr_type = build_pointer_type (fn_type);
8293       name = "__cxa_atexit";
8294     }
8295   else
8296     {
8297       /* The declaration for `atexit' is:
8298
8299            int atexit (void (*)());
8300
8301          We build up the argument types and then then function type
8302          itself.  */
8303       fn_type = build_function_type (void_type_node, void_list_node);
8304       fn_ptr_type = build_pointer_type (fn_type);
8305       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8306       /* Build the final atexit type.  */
8307       fn_type = build_function_type (integer_type_node, arg_types);
8308       name = "atexit";
8309     }
8310
8311   /* Now, build the function declaration.  */
8312   push_lang_context (lang_name_c);
8313   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8314   mark_used (atexit_fndecl);
8315   pop_lang_context ();
8316   atexit_node = default_conversion (atexit_fndecl);
8317
8318   return atexit_node;
8319 }
8320
8321 /* Returns the __dso_handle VAR_DECL.  */
8322
8323 static tree
8324 get_dso_handle_node ()
8325 {
8326   if (dso_handle_node)
8327     return dso_handle_node;
8328
8329   /* Declare the variable.  */
8330   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8331                                         ptr_type_node);
8332
8333   return dso_handle_node;
8334 }
8335
8336 /* Begin a new function with internal linkage whose job will be simply
8337    to destroy some particular variable.  */
8338
8339 static tree
8340 start_cleanup_fn ()
8341 {
8342   static int counter = 0;
8343   int old_interface_unknown = interface_unknown;
8344   char name[32];
8345   tree parmtypes;
8346   tree fntype;
8347   tree fndecl;
8348
8349   push_to_top_level ();
8350
8351   /* No need to mangle this.  */
8352   push_lang_context (lang_name_c);
8353
8354   interface_unknown = 1;
8355
8356   /* Build the parameter-types.  */
8357   parmtypes = void_list_node;
8358   /* Functions passed to __cxa_atexit take an additional parameter.
8359      We'll just ignore it.  After we implement the new calling
8360      convention for destructors, we can eliminate the use of
8361      additional cleanup functions entirely in the -fnew-abi case.  */
8362   if (flag_use_cxa_atexit)
8363     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8364   /* Build the function type itself.  */
8365   fntype = build_function_type (void_type_node, parmtypes);
8366   /* Build the name of the function.  */
8367   sprintf (name, "__tcf_%d", counter++);
8368   /* Build the function declaration.  */
8369   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8370   /* It's a function with internal linkage, generated by the
8371      compiler.  */
8372   TREE_PUBLIC (fndecl) = 0;
8373   DECL_ARTIFICIAL (fndecl) = 1;
8374   /* Make the function `inline' so that it is only emitted if it is
8375      actually needed.  It is unlikely that it will be inlined, since
8376      it is only called via a function pointer, but we avoid unncessary
8377      emissions this way.  */
8378   DECL_INLINE (fndecl) = 1;
8379   /* Build the parameter.  */
8380   if (flag_use_cxa_atexit)
8381     {
8382       tree parmdecl;
8383
8384       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8385       DECL_CONTEXT (parmdecl) = fndecl;
8386       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8387       TREE_USED (parmdecl) = 1;
8388       DECL_ARGUMENTS (fndecl) = parmdecl;
8389     }
8390
8391   pushdecl (fndecl);
8392   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8393   do_pushlevel ();
8394
8395   interface_unknown = old_interface_unknown;
8396
8397   pop_lang_context ();
8398
8399   return current_function_decl;
8400 }
8401
8402 /* Finish the cleanup function begun by start_cleanup_fn.  */
8403
8404 static void
8405 end_cleanup_fn ()
8406 {
8407   do_poplevel ();
8408
8409   expand_body (finish_function (0));
8410
8411   pop_from_top_level ();
8412 }
8413
8414 /* Generate code to handle the destruction of DECL, an object with
8415    static storage duration.  */
8416
8417 void
8418 register_dtor_fn (decl)
8419      tree decl;
8420 {
8421   tree cleanup;
8422   tree compound_stmt;
8423   tree args;
8424   tree fcall;
8425
8426   int saved_flag_access_control;
8427
8428   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8429     return;
8430
8431   /* Call build_cleanup before we enter the anonymous function so that
8432      any access checks will be done relative to the current scope,
8433      rather than the scope of the anonymous function.  */
8434   build_cleanup (decl);
8435
8436   /* Now start the function.  */
8437   cleanup = start_cleanup_fn ();
8438
8439   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8440      to the original function, rather than the anonymous one.  That
8441      will make the back-end think that nested functions are in use,
8442      which causes confusion.  */
8443   saved_flag_access_control = flag_access_control;
8444   flag_access_control = 0;
8445   fcall = build_cleanup (decl);
8446   flag_access_control = saved_flag_access_control;
8447
8448   /* Create the body of the anonymous function.  */
8449   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8450   finish_expr_stmt (fcall);
8451   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8452   end_cleanup_fn ();
8453
8454   /* Call atexit with the cleanup function.  */
8455   mark_addressable (cleanup);
8456   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8457   if (flag_use_cxa_atexit)
8458     {
8459       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8460       args = tree_cons (NULL_TREE, null_pointer_node, args);
8461       args = tree_cons (NULL_TREE, cleanup, args);
8462     }
8463   else
8464     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8465   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8466 }
8467
8468 void
8469 expand_static_init (decl, init)
8470      tree decl;
8471      tree init;
8472 {
8473   tree oldstatic = value_member (decl, static_aggregates);
8474
8475   if (oldstatic)
8476     {
8477       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8478         cp_error ("multiple initializations given for `%D'", decl);
8479     }
8480   else if (! toplevel_bindings_p ())
8481     {
8482       /* Emit code to perform this initialization but once.  */
8483       tree if_stmt;
8484       tree then_clause;
8485       tree assignment;
8486       tree guard;
8487       tree guard_init;
8488
8489       /* Emit code to perform this initialization but once.  This code
8490          looks like:
8491
8492            static int guard = 0;
8493            if (!guard) {
8494              // Do initialization.
8495              guard = 1;
8496              // Register variable for destruction at end of program.
8497            }
8498
8499          Note that the `temp' variable is only set to 1 *after* the
8500          initialization is complete.  This ensures that an exception,
8501          thrown during the construction, will cause the variable to
8502          reinitialized when we pass through this code again, as per:
8503
8504            [stmt.dcl]
8505
8506            If the initialization exits by throwing an exception, the
8507            initialization is not complete, so it will be tried again
8508            the next time control enters the declaration.
8509
8510          In theory, this process should be thread-safe, too; multiple
8511          threads should not be able to initialize the variable more
8512          than once.  We don't yet attempt to ensure thread-safety.  */
8513
8514       /* Create the guard variable.  */
8515       guard = get_guard (decl);
8516
8517       /* Begin the conditional initialization.  */
8518       if_stmt = begin_if_stmt ();
8519       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8520       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8521
8522       /* Do the initialization itself.  */
8523       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8524           || (init && TREE_CODE (init) == TREE_LIST))
8525         assignment = build_aggr_init (decl, init, 0);
8526       else if (init)
8527         /* The initialization we're doing here is just a bitwise
8528            copy.  */
8529         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8530       else
8531         assignment = NULL_TREE;
8532
8533       /* Once the assignment is complete, set TEMP to 1.  Since the
8534          construction of the static object is complete at this point,
8535          we want to make sure TEMP is set to 1 even if a temporary
8536          constructed during the initialization throws an exception
8537          when it is destroyed.  So, we combine the initialization and
8538          the assignment to TEMP into a single expression, ensuring
8539          that when we call finish_expr_stmt the cleanups will not be
8540          run until after TEMP is set to 1.  */
8541       guard_init = set_guard (guard);
8542       if (assignment)
8543         {
8544           assignment = tree_cons (NULL_TREE, assignment,
8545                                   build_tree_list (NULL_TREE,
8546                                                    guard_init));
8547           assignment = build_compound_expr (assignment);
8548         }
8549       else
8550         assignment = guard_init;
8551       finish_expr_stmt (assignment);
8552
8553       /* Use atexit to register a function for destroying this static
8554          variable.  */
8555       register_dtor_fn (decl);
8556
8557       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8558       finish_then_clause (if_stmt);
8559       finish_if_stmt ();
8560     }
8561   else
8562     static_aggregates = tree_cons (init, decl, static_aggregates);
8563 }
8564
8565 /* Finish the declaration of a catch-parameter.  */
8566
8567 tree
8568 start_handler_parms (declspecs, declarator)
8569      tree declspecs;
8570      tree declarator;
8571 {
8572   tree decl;
8573   if (declspecs)
8574     {
8575       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8576                              1, NULL_TREE);
8577       if (decl == NULL_TREE)
8578         error ("invalid catch parameter");
8579     }
8580   else
8581     decl = NULL_TREE;
8582
8583   return decl;
8584 }
8585
8586 \f
8587 /* Make TYPE a complete type based on INITIAL_VALUE.
8588    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8589    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8590
8591 int
8592 complete_array_type (type, initial_value, do_default)
8593      tree type, initial_value;
8594      int do_default;
8595 {
8596   register tree maxindex = NULL_TREE;
8597   int value = 0;
8598
8599   if (initial_value)
8600     {
8601       /* An array of character type can be initialized from a
8602          brace-enclosed string constant.  */
8603       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8604           && TREE_CODE (initial_value) == CONSTRUCTOR
8605           && CONSTRUCTOR_ELTS (initial_value)
8606           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8607               == STRING_CST)
8608           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8609         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8610
8611       /* Note MAXINDEX is really the maximum index, one less than the
8612          size.  */
8613       if (TREE_CODE (initial_value) == STRING_CST)
8614         {
8615           int eltsize
8616             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8617           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8618                                    / eltsize) - 1, 0);
8619         }
8620       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8621         {
8622           tree elts = CONSTRUCTOR_ELTS (initial_value);
8623
8624           maxindex = ssize_int (-1);
8625           for (; elts; elts = TREE_CHAIN (elts))
8626             {
8627               if (TREE_PURPOSE (elts))
8628                 maxindex = TREE_PURPOSE (elts);
8629               else
8630                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8631             }
8632           maxindex = copy_node (maxindex);
8633         }
8634       else
8635         {
8636           /* Make an error message unless that happened already.  */
8637           if (initial_value != error_mark_node)
8638             value = 1;
8639           else
8640             initial_value = NULL_TREE;
8641
8642           /* Prevent further error messages.  */
8643           maxindex = build_int_2 (0, 0);
8644         }
8645     }
8646
8647   if (!maxindex)
8648     {
8649       if (do_default)
8650         maxindex = build_int_2 (0, 0);
8651       value = 2;
8652     }
8653
8654   if (maxindex)
8655     {
8656       tree itype;
8657       tree domain;
8658
8659       domain = build_index_type (maxindex);
8660       TYPE_DOMAIN (type) = domain;
8661
8662       if (! TREE_TYPE (maxindex))
8663         TREE_TYPE (maxindex) = domain;
8664       if (initial_value)
8665         itype = TREE_TYPE (initial_value);
8666       else
8667         itype = NULL;
8668       if (itype && !TYPE_DOMAIN (itype))
8669         TYPE_DOMAIN (itype) = domain;
8670       /* The type of the main variant should never be used for arrays
8671          of different sizes.  It should only ever be completed with the
8672          size of the array.  */
8673       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8674         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8675     }
8676
8677   /* Lay out the type now that we can get the real answer.  */
8678
8679   layout_type (type);
8680
8681   return value;
8682 }
8683 \f
8684 /* Return zero if something is declared to be a member of type
8685    CTYPE when in the context of CUR_TYPE.  STRING is the error
8686    message to print in that case.  Otherwise, quietly return 1.  */
8687
8688 static int
8689 member_function_or_else (ctype, cur_type, flags)
8690      tree ctype, cur_type;
8691      enum overload_flags flags;
8692 {
8693   if (ctype && ctype != cur_type)
8694     {
8695       if (flags == DTOR_FLAG)
8696         error ("destructor for alien class `%s' cannot be a member",
8697                TYPE_NAME_STRING (ctype));
8698       else
8699         error ("constructor for alien class `%s' cannot be a member",
8700                TYPE_NAME_STRING (ctype));
8701       return 0;
8702     }
8703   return 1;
8704 }
8705 \f
8706 /* Subroutine of `grokdeclarator'.  */
8707
8708 /* Generate errors possibly applicable for a given set of specifiers.
8709    This is for ARM $7.1.2.  */
8710
8711 static void
8712 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8713      tree object;
8714      const char *type;
8715      int virtualp, quals, friendp, raises, inlinep;
8716 {
8717   if (virtualp)
8718     cp_error ("`%D' declared as a `virtual' %s", object, type);
8719   if (inlinep)
8720     cp_error ("`%D' declared as an `inline' %s", object, type);
8721   if (quals)
8722     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8723               object, type);
8724   if (friendp)
8725     cp_error_at ("`%D' declared as a friend", object);
8726   if (raises)
8727     cp_error_at ("`%D' declared with an exception specification", object);
8728 }
8729
8730 /* CTYPE is class type, or null if non-class.
8731    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8732    or METHOD_TYPE.
8733    DECLARATOR is the function's name.
8734    VIRTUALP is truthvalue of whether the function is virtual or not.
8735    FLAGS are to be passed through to `grokclassfn'.
8736    QUALS are qualifiers indicating whether the function is `const'
8737    or `volatile'.
8738    RAISES is a list of exceptions that this function can raise.
8739    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8740    not look, and -1 if we should not call `grokclassfn' at all.
8741
8742    Returns `NULL_TREE' if something goes wrong, after issuing
8743    applicable error messages.  */
8744
8745 static tree
8746 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8747             raises, check, friendp, publicp, inlinep, funcdef_flag,
8748             template_count, in_namespace)
8749      tree ctype, type;
8750      tree declarator;
8751      tree orig_declarator;
8752      int virtualp;
8753      enum overload_flags flags;
8754      tree quals, raises;
8755      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8756      tree in_namespace;
8757 {
8758   tree cname, decl;
8759   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8760   int has_default_arg = 0;
8761   tree t;
8762
8763   if (ctype)
8764     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8765       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8766   else
8767     cname = NULL_TREE;
8768
8769   if (raises)
8770     {
8771       type = build_exception_variant (type, raises);
8772     }
8773
8774   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8775   /* Propagate volatile out from type to decl. */
8776   if (TYPE_VOLATILE (type))
8777     TREE_THIS_VOLATILE (decl) = 1;
8778
8779   /* If this decl has namespace scope, set that up.  */
8780   if (in_namespace)
8781     set_decl_namespace (decl, in_namespace, friendp);
8782   else if (!ctype)
8783     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8784
8785   /* `main' and builtins have implicit 'C' linkage.  */
8786   if ((MAIN_NAME_P (declarator)
8787        || (IDENTIFIER_LENGTH (declarator) > 10
8788            && IDENTIFIER_POINTER (declarator)[0] == '_'
8789            && IDENTIFIER_POINTER (declarator)[1] == '_'
8790            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8791       && current_lang_name == lang_name_cplusplus
8792       && ctype == NULL_TREE
8793       /* NULL_TREE means global namespace.  */
8794       && DECL_CONTEXT (decl) == NULL_TREE)
8795     DECL_LANGUAGE (decl) = lang_c;
8796
8797   /* Should probably propagate const out from type to decl I bet (mrs).  */
8798   if (staticp)
8799     {
8800       DECL_STATIC_FUNCTION_P (decl) = 1;
8801       DECL_CONTEXT (decl) = ctype;
8802     }
8803
8804   if (ctype)
8805     DECL_CONTEXT (decl) = ctype;
8806
8807   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8808     {
8809       if (processing_template_decl)
8810         error ("cannot declare `::main' to be a template");
8811       if (inlinep)
8812         error ("cannot declare `::main' to be inline");
8813       else if (! publicp)
8814         error ("cannot declare `::main' to be static");
8815       inlinep = 0;
8816       publicp = 1;
8817     }
8818
8819   /* Members of anonymous types and local classes have no linkage; make
8820      them internal.  */
8821   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8822                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8823     publicp = 0;
8824
8825   if (publicp)
8826     {
8827       /* [basic.link]: A name with no linkage (notably, the name of a class
8828          or enumeration declared in a local scope) shall not be used to
8829          declare an entity with linkage.
8830
8831          Only check this for public decls for now.  */
8832       t = no_linkage_check (TREE_TYPE (decl));
8833       if (t)
8834         {
8835           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8836             {
8837               if (DECL_EXTERN_C_P (decl))
8838                 /* Allow this; it's pretty common in C.  */;
8839               else
8840                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8841                             decl);
8842             }
8843           else
8844             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8845                         decl, t);
8846         }
8847     }
8848
8849   TREE_PUBLIC (decl) = publicp;
8850   if (! publicp)
8851     {
8852       DECL_INTERFACE_KNOWN (decl) = 1;
8853       DECL_NOT_REALLY_EXTERN (decl) = 1;
8854     }
8855
8856   if (inlinep)
8857     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8858
8859   DECL_EXTERNAL (decl) = 1;
8860   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8861     {
8862       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8863                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8864       quals = NULL_TREE;
8865     }
8866
8867   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8868     grok_op_properties (decl, virtualp, check < 0);
8869
8870   if (ctype && decl_function_context (decl))
8871     DECL_NO_STATIC_CHAIN (decl) = 1;
8872
8873   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8874     if (TREE_PURPOSE (t)
8875         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8876       {
8877         has_default_arg = 1;
8878         break;
8879       }
8880
8881   if (friendp
8882       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8883     {
8884       if (funcdef_flag)
8885         cp_error
8886           ("defining explicit specialization `%D' in friend declaration",
8887            orig_declarator);
8888       else
8889         {
8890           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8891             {
8892               /* Something like `template <class T> friend void f<T>()'.  */
8893               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8894                         orig_declarator);
8895               return NULL_TREE;
8896             }
8897
8898
8899           /* A friend declaration of the form friend void f<>().  Record
8900              the information in the TEMPLATE_ID_EXPR.  */
8901           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8902           DECL_TEMPLATE_INFO (decl)
8903             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8904                          TREE_OPERAND (orig_declarator, 1),
8905                          NULL_TREE);
8906
8907           if (has_default_arg)
8908             {
8909               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8910                         decl);
8911               return NULL_TREE;
8912             }
8913
8914           if (inlinep)
8915             {
8916               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8917                         decl);
8918               return NULL_TREE;
8919             }
8920         }
8921     }
8922
8923   if (has_default_arg)
8924     add_defarg_fn (decl);
8925
8926   /* Plain overloading: will not be grok'd by grokclassfn.  */
8927   if (! ctype && ! processing_template_decl
8928       && !DECL_EXTERN_C_P (decl)
8929       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8930     set_mangled_name_for_decl (decl);
8931
8932   if (funcdef_flag)
8933     /* Make the init_value nonzero so pushdecl knows this is not
8934        tentative.  error_mark_node is replaced later with the BLOCK.  */
8935     DECL_INITIAL (decl) = error_mark_node;
8936
8937   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8938     TREE_NOTHROW (decl) = 1;
8939
8940   /* Caller will do the rest of this.  */
8941   if (check < 0)
8942     return decl;
8943
8944   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8945     DECL_CONSTRUCTOR_P (decl) = 1;
8946
8947   /* Function gets the ugly name, field gets the nice one.  This call
8948      may change the type of the function (because of default
8949      parameters)!  */
8950   if (ctype != NULL_TREE)
8951     grokclassfn (ctype, decl, flags, quals);
8952
8953   decl = check_explicit_specialization (orig_declarator, decl,
8954                                         template_count,
8955                                         2 * (funcdef_flag != 0) +
8956                                         4 * (friendp != 0));
8957   if (decl == error_mark_node)
8958     return NULL_TREE;
8959
8960   if (ctype != NULL_TREE
8961       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8962       && check)
8963     {
8964       tree old_decl;
8965
8966       old_decl = check_classfn (ctype, decl);
8967
8968       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8969         /* Because grokfndecl is always supposed to return a
8970            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8971            here.  We depend on our callers to figure out that its
8972            really a template that's being returned.  */
8973         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8974
8975       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8976           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8977         {
8978           /* Remove the `this' parm added by grokclassfn.
8979              XXX Isn't this done in start_function, too?  */
8980           revert_static_member_fn (decl);
8981           last_function_parms = TREE_CHAIN (last_function_parms);
8982         }
8983       if (old_decl && DECL_ARTIFICIAL (old_decl))
8984         cp_error ("definition of implicitly-declared `%D'", old_decl);
8985
8986       if (old_decl)
8987         {
8988           /* Since we've smashed OLD_DECL to its
8989              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8990           if (TREE_CODE (decl) == TEMPLATE_DECL)
8991             decl = DECL_TEMPLATE_RESULT (decl);
8992
8993           /* Attempt to merge the declarations.  This can fail, in
8994              the case of some illegal specialization declarations.  */
8995           if (!duplicate_decls (decl, old_decl))
8996             cp_error ("no `%#D' member function declared in class `%T'",
8997                       decl, ctype);
8998           return old_decl;
8999         }
9000     }
9001
9002   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9003     return NULL_TREE;
9004
9005   if (ctype == NULL_TREE || check)
9006     return decl;
9007
9008   if (virtualp)
9009     {
9010       DECL_VIRTUAL_P (decl) = 1;
9011       if (DECL_VINDEX (decl) == NULL_TREE)
9012         DECL_VINDEX (decl) = error_mark_node;
9013       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9014     }
9015
9016   return decl;
9017 }
9018
9019 static tree
9020 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9021      tree type;
9022      tree declarator;
9023      RID_BIT_TYPE *specbits_in;
9024      int initialized;
9025      int constp;
9026      tree in_namespace;
9027 {
9028   tree decl;
9029   RID_BIT_TYPE specbits;
9030
9031   specbits = *specbits_in;
9032
9033   if (TREE_CODE (type) == OFFSET_TYPE)
9034     {
9035       /* If you declare a static member so that it
9036          can be initialized, the code will reach here.  */
9037       tree basetype = TYPE_OFFSET_BASETYPE (type);
9038       type = TREE_TYPE (type);
9039       decl = build_lang_decl (VAR_DECL, declarator, type);
9040       DECL_CONTEXT (decl) = basetype;
9041       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9042          templates.  */
9043       if (!uses_template_parms (decl))
9044         {
9045           if (flag_new_abi)
9046             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9047           else
9048             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9049                                                             declarator);
9050         }
9051     }
9052   else
9053     {
9054       tree context;
9055
9056       if (in_namespace)
9057         context = in_namespace;
9058       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9059         context = current_namespace;
9060       else
9061         context = NULL_TREE;
9062
9063       if (processing_template_decl && context)
9064         /* For global variables, declared in a template, we need the
9065            full lang_decl.  */
9066         decl = build_lang_decl (VAR_DECL, declarator, type);
9067       else
9068         decl = build_decl (VAR_DECL, declarator, type);
9069
9070       if (context)
9071         set_decl_namespace (decl, context, 0);
9072
9073       context = DECL_CONTEXT (decl);
9074       if (declarator && context && current_lang_name != lang_name_c)
9075         {
9076           if (flag_new_abi)
9077             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9078           else
9079             DECL_ASSEMBLER_NAME (decl)
9080               = build_static_name (context, declarator);
9081         }
9082     }
9083
9084   if (in_namespace)
9085     set_decl_namespace (decl, in_namespace, 0);
9086
9087   if (RIDBIT_SETP (RID_EXTERN, specbits))
9088     {
9089       DECL_THIS_EXTERN (decl) = 1;
9090       DECL_EXTERNAL (decl) = !initialized;
9091     }
9092
9093   /* In class context, static means one per class,
9094      public access, and static storage.  */
9095   if (DECL_CLASS_SCOPE_P (decl))
9096     {
9097       TREE_PUBLIC (decl) = 1;
9098       TREE_STATIC (decl) = 1;
9099       DECL_EXTERNAL (decl) = 0;
9100     }
9101   /* At top level, either `static' or no s.c. makes a definition
9102      (perhaps tentative), and absence of `static' makes it public.  */
9103   else if (toplevel_bindings_p ())
9104     {
9105       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9106                             && (DECL_THIS_EXTERN (decl) || ! constp));
9107       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9108     }
9109   /* Not at top level, only `static' makes a static definition.  */
9110   else
9111     {
9112       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9113       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9114     }
9115
9116   if (TREE_PUBLIC (decl))
9117     {
9118       /* [basic.link]: A name with no linkage (notably, the name of a class
9119          or enumeration declared in a local scope) shall not be used to
9120          declare an entity with linkage.
9121
9122          Only check this for public decls for now.  */
9123       tree t = no_linkage_check (TREE_TYPE (decl));
9124       if (t)
9125         {
9126           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9127             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9128           else
9129             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9130                         decl, t);
9131         }
9132     }
9133
9134   return decl;
9135 }
9136
9137 /* Create and return a canonical pointer to member function type, for
9138    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9139
9140 tree
9141 build_ptrmemfunc_type (type)
9142      tree type;
9143 {
9144   tree fields[4];
9145   tree t;
9146   tree u;
9147   tree unqualified_variant = NULL_TREE;
9148
9149   /* If a canonical type already exists for this type, use it.  We use
9150      this method instead of type_hash_canon, because it only does a
9151      simple equality check on the list of field members.  */
9152
9153   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9154     return t;
9155
9156   /* Make sure that we always have the unqualified pointer-to-member
9157      type first.  */
9158   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9159     unqualified_variant
9160       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9161
9162   t = make_aggr_type (RECORD_TYPE);
9163   /* Let the front-end know this is a pointer to member function...  */
9164   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9165   /* ... and not really an aggregate.  */
9166   SET_IS_AGGR_TYPE (t, 0);
9167
9168   if (!flag_new_abi)
9169     {
9170       u = make_aggr_type (UNION_TYPE);
9171       SET_IS_AGGR_TYPE (u, 0);
9172       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9173       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9174                               delta_type_node);
9175       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9176       TYPE_NAME (u) = NULL_TREE;
9177
9178       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9179                               delta_type_node);
9180       fields[1] = build_decl (FIELD_DECL, index_identifier,
9181                               delta_type_node);
9182       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9183       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9184     }
9185   else
9186     {
9187       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9188       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9189                               delta_type_node);
9190       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9191     }
9192
9193   /* Zap out the name so that the back-end will give us the debugging
9194      information for this anonymous RECORD_TYPE.  */
9195   TYPE_NAME (t) = NULL_TREE;
9196
9197   /* If this is not the unqualified form of this pointer-to-member
9198      type, set the TYPE_MAIN_VARIANT for this type to be the
9199      unqualified type.  Since they are actually RECORD_TYPEs that are
9200      not variants of each other, we must do this manually.  */
9201   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9202     {
9203       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9204       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9205       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9206       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9207     }
9208
9209   /* Cache this pointer-to-member type so that we can find it again
9210      later.  */
9211   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9212
9213   /* Seems to be wanted.  */
9214   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9215
9216   return t;
9217 }
9218
9219 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9220    Check to see that the definition is valid.  Issue appropriate error
9221    messages.  Return 1 if the definition is particularly bad, or 0
9222    otherwise.  */
9223
9224 int
9225 check_static_variable_definition (decl, type)
9226      tree decl;
9227      tree type;
9228 {
9229   /* Motion 10 at San Diego: If a static const integral data member is
9230      initialized with an integral constant expression, the initializer
9231      may appear either in the declaration (within the class), or in
9232      the definition, but not both.  If it appears in the class, the
9233      member is a member constant.  The file-scope definition is always
9234      required.  */
9235   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9236     {
9237       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9238                 type);
9239       /* If we just return the declaration, crashes will sometimes
9240          occur.  We therefore return void_type_node, as if this was a
9241          friend declaration, to cause callers to completely ignore
9242          this declaration.  */
9243       return 1;
9244     }
9245   else if (!CP_TYPE_CONST_P (type))
9246     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9247               decl);
9248   else if (pedantic && !INTEGRAL_TYPE_P (type))
9249     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9250
9251   return 0;
9252 }
9253
9254 /* Given the SIZE (i.e., number of elements) in an array, compute an
9255    appropriate index type for the array.  If non-NULL, NAME is the
9256    name of the thing being declared.  */
9257
9258 tree
9259 compute_array_index_type (name, size)
9260      tree name;
9261      tree size;
9262 {
9263   tree itype;
9264
9265   /* The size might be the result of a cast. */
9266   STRIP_TYPE_NOPS (size);
9267
9268   /* It might be a const variable or enumeration constant.  */
9269   size = decl_constant_value (size);
9270
9271   /* If this involves a template parameter, it will be a constant at
9272      instantiation time, but we don't know what the value is yet.
9273      Even if no template parameters are involved, we may an expression
9274      that is not a constant; we don't even simplify `1 + 2' when
9275      processing a template.  */
9276   if (processing_template_decl)
9277     {
9278       /* Resolve a qualified reference to an enumerator or static
9279          const data member of ours.  */
9280       if (TREE_CODE (size) == SCOPE_REF
9281           && TREE_OPERAND (size, 0) == current_class_type)
9282         {
9283           tree t = lookup_field (current_class_type,
9284                                  TREE_OPERAND (size, 1), 0, 0);
9285           if (t)
9286             size = t;
9287         }
9288
9289       return build_index_type (build_min (MINUS_EXPR, sizetype,
9290                                           size, integer_one_node));
9291     }
9292
9293   /* The array bound must be an integer type.  */
9294   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9295       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9296       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9297     {
9298       if (name)
9299         cp_error ("size of array `%D' has non-integer type", name);
9300       else
9301         cp_error ("size of array has non-integer type");
9302       size = integer_one_node;
9303     }
9304
9305   /* Normally, the array-bound will be a constant.  */
9306   if (TREE_CODE (size) == INTEGER_CST)
9307     {
9308       /* Check to see if the array bound overflowed.  Make that an
9309          error, no matter how generous we're being.  */
9310       int old_flag_pedantic_errors = flag_pedantic_errors;
9311       int old_pedantic = pedantic;
9312       pedantic = flag_pedantic_errors = 1;
9313       constant_expression_warning (size);
9314       pedantic = old_pedantic;
9315       flag_pedantic_errors = old_flag_pedantic_errors;
9316
9317       /* An array must have a positive number of elements.  */
9318       if (INT_CST_LT (size, integer_zero_node))
9319         {
9320           if (name)
9321             cp_error ("size of array `%D' is negative", name);
9322           else
9323             cp_error ("size of array is negative");
9324           size = integer_one_node;
9325         }
9326       /* Except that an extension we allow zero-sized arrays.  We
9327          always allow them in system headers because glibc uses
9328          them.  */
9329       else if (integer_zerop (size) && pedantic && !in_system_header)
9330         {
9331           if (name)
9332             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9333           else
9334             cp_pedwarn ("ISO C++ forbids zero-size array");
9335         }
9336     }
9337   else if (TREE_CONSTANT (size))
9338     {
9339       /* `(int) &fn' is not a valid array bound.  */
9340       if (name)
9341         cp_error ("size of array `%D' is not an integral constant-expression",
9342                   name);
9343       else
9344         cp_error ("size of array is not an integral constant-expression");
9345     }
9346
9347   /* Compute the index of the largest element in the array.  It is
9348      one less than the number of elements in the array.  */
9349   itype
9350     = fold (cp_build_binary_op (MINUS_EXPR,
9351                                 cp_convert (ssizetype, size),
9352                                 cp_convert (ssizetype,
9353                                             integer_one_node)));
9354
9355   /* Check for variable-sized arrays.  We allow such things as an
9356      extension, even though they are not allowed in ANSI/ISO C++.  */
9357   if (!TREE_CONSTANT (itype))
9358     {
9359       if (pedantic)
9360         {
9361           if (name)
9362             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9363                         name);
9364           else
9365             cp_pedwarn ("ISO C++ forbids variable-size array");
9366         }
9367
9368       /* Create a variable-sized array index type.  */
9369       itype = variable_size (itype);
9370     }
9371   /* Make sure that there was no overflow when creating to a signed
9372      index type.  (For example, on a 32-bit machine, an array with
9373      size 2^32 - 1 is too big.)  */
9374   else if (TREE_OVERFLOW (itype))
9375     {
9376       error ("overflow in array dimension");
9377       TREE_OVERFLOW (itype) = 0;
9378     }
9379
9380   /* Create and return the appropriate index type.  */
9381   return build_index_type (itype);
9382 }
9383
9384 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9385    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9386    with this type.  */
9387
9388 static tree
9389 create_array_type_for_decl (name, type, size)
9390      tree name;
9391      tree type;
9392      tree size;
9393 {
9394   tree itype = NULL_TREE;
9395   const char* error_msg;
9396
9397   /* If things have already gone awry, bail now.  */
9398   if (type == error_mark_node || size == error_mark_node)
9399     return error_mark_node;
9400
9401   /* Assume that everything will go OK.  */
9402   error_msg = NULL;
9403
9404   /* There are some types which cannot be array elements.  */
9405   switch (TREE_CODE (type))
9406     {
9407     case VOID_TYPE:
9408       error_msg = "array of void";
9409       break;
9410
9411     case FUNCTION_TYPE:
9412       error_msg = "array of functions";
9413       break;
9414
9415     case REFERENCE_TYPE:
9416       error_msg = "array of references";
9417       break;
9418
9419     case OFFSET_TYPE:
9420       error_msg = "array of data members";
9421       break;
9422
9423     case METHOD_TYPE:
9424       error_msg = "array of function members";
9425       break;
9426
9427     default:
9428       break;
9429     }
9430
9431   /* If something went wrong, issue an error-message and return.  */
9432   if (error_msg)
9433     {
9434       if (name)
9435         cp_error ("declaration of `%D' as %s", name, error_msg);
9436       else
9437         cp_error ("creating %s", error_msg);
9438
9439       return error_mark_node;
9440     }
9441
9442   /* [dcl.array]
9443
9444      The constant expressions that specify the bounds of the arrays
9445      can be omitted only for the first member of the sequence.  */
9446   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9447     {
9448       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9449                 name);
9450
9451       return error_mark_node;
9452     }
9453
9454   /* Figure out the index type for the array.  */
9455   if (size)
9456     itype = compute_array_index_type (name, size);
9457
9458   return build_cplus_array_type (type, itype);
9459 }
9460
9461 /* Check that it's OK to declare a function with the indicated TYPE.
9462    SFK indicates the kind of special function (if any) that this
9463    function is.  CTYPE is the class of which this function is a
9464    member.  OPTYPE is the type given in a conversion operator
9465    declaration.  Returns the actual return type of the function; that
9466    may be different than TYPE if an error occurs, or for certain
9467    special functions.  */
9468
9469 static tree
9470 check_special_function_return_type (sfk, type, ctype, optype)
9471      special_function_kind sfk;
9472      tree type;
9473      tree ctype;
9474      tree optype;
9475 {
9476   switch (sfk)
9477     {
9478     case sfk_constructor:
9479       if (type)
9480         cp_error ("return type specification for constructor invalid");
9481
9482       /* In the old ABI, we return `this'; in the new ABI we don't
9483          bother.  */
9484       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9485       break;
9486
9487     case sfk_destructor:
9488       if (type)
9489         cp_error ("return type specification for destructor invalid");
9490       type = void_type_node;
9491       break;
9492
9493     case sfk_conversion:
9494       if (type && !same_type_p (type, optype))
9495         cp_error ("operator `%T' declared to return `%T'", optype, type);
9496       else if (type)
9497         cp_pedwarn ("return type specified for `operator %T'",  optype);
9498       type = optype;
9499       break;
9500
9501     default:
9502       my_friendly_abort (20000408);
9503       break;
9504     }
9505
9506   return type;
9507 }
9508
9509 /* Given declspecs and a declarator,
9510    determine the name and type of the object declared
9511    and construct a ..._DECL node for it.
9512    (In one case we can return a ..._TYPE node instead.
9513     For invalid input we sometimes return 0.)
9514
9515    DECLSPECS is a chain of tree_list nodes whose value fields
9516     are the storage classes and type specifiers.
9517
9518    DECL_CONTEXT says which syntactic context this declaration is in:
9519      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9520      FUNCDEF for a function definition.  Like NORMAL but a few different
9521       error messages in each case.  Return value may be zero meaning
9522       this definition is too screwy to try to parse.
9523      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9524       handle member functions (which have FIELD context).
9525       Return value may be zero meaning this definition is too screwy to
9526       try to parse.
9527      PARM for a parameter declaration (either within a function prototype
9528       or before a function body).  Make a PARM_DECL, or return void_type_node.
9529      CATCHPARM for a parameter declaration before a catch clause.
9530      TYPENAME if for a typename (in a cast or sizeof).
9531       Don't make a DECL node; just return the ..._TYPE node.
9532      FIELD for a struct or union field; make a FIELD_DECL.
9533      BITFIELD for a field with specified width.
9534    INITIALIZED is 1 if the decl has an initializer.
9535
9536    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9537    normal attributes in TREE_PURPOSE, or NULL_TREE.
9538
9539    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9540    It may also be so in the PARM case, for a prototype where the
9541    argument type is specified but not the name.
9542
9543    This function is where the complicated C meanings of `static'
9544    and `extern' are interpreted.
9545
9546    For C++, if there is any monkey business to do, the function which
9547    calls this one must do it, i.e., prepending instance variables,
9548    renaming overloaded function names, etc.
9549
9550    Note that for this C++, it is an error to define a method within a class
9551    which does not belong to that class.
9552
9553    Except in the case where SCOPE_REFs are implicitly known (such as
9554    methods within a class being redundantly qualified),
9555    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9556    (class_name::decl_name).  The caller must also deal with this.
9557
9558    If a constructor or destructor is seen, and the context is FIELD,
9559    then the type gains the attribute TREE_HAS_x.  If such a declaration
9560    is erroneous, NULL_TREE is returned.
9561
9562    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9563    function, these are the qualifiers to give to the `this' pointer. We
9564    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9565
9566    May return void_type_node if the declarator turned out to be a friend.
9567    See grokfield for details.  */
9568
9569 tree
9570 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9571      tree declspecs;
9572      tree declarator;
9573      enum decl_context decl_context;
9574      int initialized;
9575      tree attrlist;
9576 {
9577   RID_BIT_TYPE specbits;
9578   int nclasses = 0;
9579   tree spec;
9580   tree type = NULL_TREE;
9581   int longlong = 0;
9582   int constp;
9583   int restrictp;
9584   int volatilep;
9585   int type_quals;
9586   int virtualp, explicitp, friendp, inlinep, staticp;
9587   int explicit_int = 0;
9588   int explicit_char = 0;
9589   int defaulted_int = 0;
9590   tree typedef_decl = NULL_TREE;
9591   const char *name;
9592   tree typedef_type = NULL_TREE;
9593   int funcdef_flag = 0;
9594   enum tree_code innermost_code = ERROR_MARK;
9595   int bitfield = 0;
9596 #if 0
9597   /* See the code below that used this.  */
9598   tree decl_machine_attr = NULL_TREE;
9599 #endif
9600   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9601      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9602   tree init = NULL_TREE;
9603
9604   /* Keep track of what sort of function is being processed
9605      so that we can warn about default return values, or explicit
9606      return values which do not match prescribed defaults.  */
9607   special_function_kind sfk = sfk_none;
9608
9609   tree dname = NULL_TREE;
9610   tree ctype = current_class_type;
9611   tree ctor_return_type = NULL_TREE;
9612   enum overload_flags flags = NO_SPECIAL;
9613   tree quals = NULL_TREE;
9614   tree raises = NULL_TREE;
9615   int template_count = 0;
9616   tree in_namespace = NULL_TREE;
9617   tree inner_attrs;
9618   int ignore_attrs;
9619
9620   RIDBIT_RESET_ALL (specbits);
9621   if (decl_context == FUNCDEF)
9622     funcdef_flag = 1, decl_context = NORMAL;
9623   else if (decl_context == MEMFUNCDEF)
9624     funcdef_flag = -1, decl_context = FIELD;
9625   else if (decl_context == BITFIELD)
9626     bitfield = 1, decl_context = FIELD;
9627
9628   /* Look inside a declarator for the name being declared
9629      and get it as a string, for an error message.  */
9630   {
9631     tree *next = &declarator;
9632     register tree decl;
9633     name = NULL;
9634
9635     while (next && *next)
9636       {
9637         decl = *next;
9638         switch (TREE_CODE (decl))
9639           {
9640           case TREE_LIST:
9641             /* For attributes.  */
9642             next = &TREE_VALUE (decl);
9643             break;
9644
9645           case COND_EXPR:
9646             ctype = NULL_TREE;
9647             next = &TREE_OPERAND (decl, 0);
9648             break;
9649
9650           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9651             {
9652               tree name = TREE_OPERAND (decl, 0);
9653               tree rename = NULL_TREE;
9654
9655               my_friendly_assert (flags == NO_SPECIAL, 152);
9656               flags = DTOR_FLAG;
9657               sfk = sfk_destructor;
9658               if (TREE_CODE (name) == TYPE_DECL)
9659                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9660               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9661               if (ctype == NULL_TREE)
9662                 {
9663                   if (current_class_type == NULL_TREE)
9664                     {
9665                       error ("destructors must be member functions");
9666                       flags = NO_SPECIAL;
9667                     }
9668                   else
9669                     {
9670                       tree t = constructor_name (current_class_name);
9671                       if (t != name)
9672                         rename = t;
9673                     }
9674                 }
9675               else
9676                 {
9677                   tree t = constructor_name (ctype);
9678                   if (t != name)
9679                     rename = t;
9680                 }
9681
9682               if (rename)
9683                 {
9684                   cp_error ("destructor `%T' must match class name `%T'",
9685                             name, rename);
9686                   TREE_OPERAND (decl, 0) = rename;
9687                 }
9688               next = &name;
9689             }
9690             break;
9691
9692           case ADDR_EXPR:       /* C++ reference declaration */
9693             /* Fall through. */
9694           case ARRAY_REF:
9695           case INDIRECT_REF:
9696             ctype = NULL_TREE;
9697             innermost_code = TREE_CODE (decl);
9698             next = &TREE_OPERAND (decl, 0);
9699             break;
9700
9701           case CALL_EXPR:
9702             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9703               {
9704                 /* This is actually a variable declaration using
9705                    constructor syntax.  We need to call start_decl and
9706                    cp_finish_decl so we can get the variable
9707                    initialized...  */
9708
9709                 tree attributes, prefix_attributes;
9710
9711                 *next = TREE_OPERAND (decl, 0);
9712                 init = CALL_DECLARATOR_PARMS (decl);
9713
9714                 if (attrlist)
9715                   {
9716                     attributes = TREE_PURPOSE (attrlist);
9717                     prefix_attributes = TREE_VALUE (attrlist);
9718                   }
9719                 else
9720                   {
9721                     attributes = NULL_TREE;
9722                     prefix_attributes = NULL_TREE;
9723                   }
9724
9725                 decl = start_decl (declarator, declspecs, 1,
9726                                    attributes, prefix_attributes);
9727                 decl_type_access_control (decl);
9728                 if (decl)
9729                   {
9730                     /* Look for __unused__ attribute */
9731                     if (TREE_USED (TREE_TYPE (decl)))
9732                       TREE_USED (decl) = 1;
9733                     finish_decl (decl, init, NULL_TREE);
9734                   }
9735                 else
9736                   cp_error ("invalid declarator");
9737                 return 0;
9738               }
9739             innermost_code = TREE_CODE (decl);
9740             if (decl_context == FIELD && ctype == NULL_TREE)
9741               ctype = current_class_type;
9742             if (ctype
9743                 && TREE_OPERAND (decl, 0)
9744                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9745                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9746                          == constructor_name_full (ctype))
9747                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9748                             == constructor_name (ctype)))))
9749               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9750             next = &TREE_OPERAND (decl, 0);
9751             decl = *next;
9752             if (ctype != NULL_TREE
9753                 && decl != NULL_TREE && flags != DTOR_FLAG
9754                 && decl == constructor_name (ctype))
9755               {
9756                 sfk = sfk_constructor;
9757                 ctor_return_type = ctype;
9758               }
9759             ctype = NULL_TREE;
9760             break;
9761
9762           case TEMPLATE_ID_EXPR:
9763               {
9764                 tree fns = TREE_OPERAND (decl, 0);
9765
9766                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9767                   fns = TREE_OPERAND (fns, 0);
9768
9769                 dname = fns;
9770                 if (TREE_CODE (dname) == COMPONENT_REF)
9771                   dname = TREE_OPERAND (dname, 1);
9772                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9773                   {
9774                     my_friendly_assert (is_overloaded_fn (dname),
9775                                         19990331);
9776                     dname = DECL_NAME (get_first_fn (dname));
9777                   }
9778               }
9779           /* Fall through. */
9780
9781           case IDENTIFIER_NODE:
9782             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9783               dname = decl;
9784
9785             next = 0;
9786
9787             if (is_rid (dname))
9788               {
9789                 cp_error ("declarator-id missing; using reserved word `%D'",
9790                           dname);
9791                 name = IDENTIFIER_POINTER (dname);
9792               }
9793             else if (!IDENTIFIER_TYPENAME_P (dname))
9794               name = IDENTIFIER_POINTER (dname);
9795             else
9796               {
9797                 my_friendly_assert (flags == NO_SPECIAL, 154);
9798                 flags = TYPENAME_FLAG;
9799                 ctor_return_type = TREE_TYPE (dname);
9800                 sfk = sfk_conversion;
9801                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9802                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9803                         == TYPE_DECL))
9804                   name = IDENTIFIER_POINTER (dname);
9805                 else
9806                   name = "<invalid operator>";
9807               }
9808             break;
9809
9810             /* C++ extension */
9811           case SCOPE_REF:
9812             {
9813               /* Perform error checking, and decide on a ctype.  */
9814               tree cname = TREE_OPERAND (decl, 0);
9815               if (cname == NULL_TREE)
9816                 ctype = NULL_TREE;
9817               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9818                 {
9819                   ctype = NULL_TREE;
9820                   in_namespace = TREE_OPERAND (decl, 0);
9821                   TREE_OPERAND (decl, 0) = NULL_TREE;
9822                 }
9823               else if (! is_aggr_type (cname, 1))
9824                 TREE_OPERAND (decl, 0) = NULL_TREE;
9825               /* Must test TREE_OPERAND (decl, 1), in case user gives
9826                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9827               else if (TREE_OPERAND (decl, 1)
9828                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9829                 ctype = cname;
9830               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9831                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9832                 {
9833                   cp_error ("`%T::%D' is not a valid declarator", cname,
9834                             TREE_OPERAND (decl, 1));
9835                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9836                             cname, TREE_OPERAND (decl, 1));
9837                   return void_type_node;
9838                 }
9839               else if (ctype == NULL_TREE)
9840                 ctype = cname;
9841               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9842                 TREE_OPERAND (decl, 0) = ctype;
9843               else
9844                 {
9845                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9846                     {
9847                       cp_error ("type `%T' is not derived from type `%T'",
9848                                 cname, ctype);
9849                       TREE_OPERAND (decl, 0) = NULL_TREE;
9850                     }
9851                   else
9852                     ctype = cname;
9853                 }
9854
9855               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9856                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9857                        == constructor_name_full (ctype))
9858                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9859                           == constructor_name (ctype))))
9860                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9861               next = &TREE_OPERAND (decl, 1);
9862               decl = *next;
9863               if (ctype)
9864                 {
9865                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9866                       && constructor_name (ctype) == decl)
9867                     {
9868                       sfk = sfk_constructor;
9869                       ctor_return_type = ctype;
9870                     }
9871                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9872                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9873                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9874                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9875                     {
9876                       sfk = sfk_destructor;
9877                       ctor_return_type = ctype;
9878                       flags = DTOR_FLAG;
9879                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9880                       next = &TREE_OPERAND (decl, 0);
9881                     }
9882                 }
9883             }
9884             break;
9885
9886           case ERROR_MARK:
9887             next = 0;
9888             break;
9889
9890           case TYPE_DECL:
9891             /* Parse error puts this typespec where
9892                a declarator should go.  */
9893             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9894             if (TREE_TYPE (decl) == current_class_type)
9895               cp_error ("  perhaps you want `%T' for a constructor",
9896                         current_class_name);
9897             dname = DECL_NAME (decl);
9898             name = IDENTIFIER_POINTER (dname);
9899
9900             /* Avoid giving two errors for this.  */
9901             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9902
9903             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9904             *next = dname;
9905             next = 0;
9906             break;
9907
9908           default:
9909             cp_compiler_error ("`%D' as declarator", decl);
9910             return 0; /* We used to do a 155 abort here.  */
9911           }
9912       }
9913   }
9914
9915   /* A function definition's declarator must have the form of
9916      a function declarator.  */
9917
9918   if (funcdef_flag && innermost_code != CALL_EXPR)
9919     return 0;
9920
9921   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9922       && innermost_code != CALL_EXPR
9923       && ! (ctype && declspecs == NULL_TREE))
9924     {
9925       cp_error ("declaration of `%D' as non-function", dname);
9926       return void_type_node;
9927     }
9928
9929   /* Anything declared one level down from the top level
9930      must be one of the parameters of a function
9931      (because the body is at least two levels down).  */
9932
9933   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9934      by not allowing C++ class definitions to specify their parameters
9935      with xdecls (must be spec.d in the parmlist).
9936
9937      Since we now wait to push a class scope until we are sure that
9938      we are in a legitimate method context, we must set oldcname
9939      explicitly (since current_class_name is not yet alive).
9940
9941      We also want to avoid calling this a PARM if it is in a namespace.  */
9942
9943   if (decl_context == NORMAL && !toplevel_bindings_p ())
9944     {
9945       struct binding_level *b = current_binding_level;
9946       current_binding_level = b->level_chain;
9947       if (current_binding_level != 0 && toplevel_bindings_p ())
9948         decl_context = PARM;
9949       current_binding_level = b;
9950     }
9951
9952   if (name == NULL)
9953     name = decl_context == PARM ? "parameter" : "type name";
9954
9955   /* Look through the decl specs and record which ones appear.
9956      Some typespecs are defined as built-in typenames.
9957      Others, the ones that are modifiers of other types,
9958      are represented by bits in SPECBITS: set the bits for
9959      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9960
9961      If there is a typedef name or a type, store the type in TYPE.
9962      This includes builtin typedefs such as `int'.
9963
9964      Set EXPLICIT_INT if the type is `int' or `char' and did not
9965      come from a user typedef.
9966
9967      Set LONGLONG if `long' is mentioned twice.
9968
9969      For C++, constructors and destructors have their own fast treatment.  */
9970
9971   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9972     {
9973       register int i;
9974       register tree id;
9975
9976       /* Certain parse errors slip through.  For example,
9977          `int class;' is not caught by the parser. Try
9978          weakly to recover here.  */
9979       if (TREE_CODE (spec) != TREE_LIST)
9980         return 0;
9981
9982       id = TREE_VALUE (spec);
9983
9984       if (TREE_CODE (id) == IDENTIFIER_NODE)
9985         {
9986           if (id == ridpointers[(int) RID_INT]
9987               || id == ridpointers[(int) RID_CHAR]
9988               || id == ridpointers[(int) RID_BOOL]
9989               || id == ridpointers[(int) RID_WCHAR])
9990             {
9991               if (type)
9992                 {
9993                   if (id == ridpointers[(int) RID_BOOL])
9994                     error ("`bool' is now a keyword");
9995                   else
9996                     cp_error ("extraneous `%T' ignored", id);
9997                 }
9998               else
9999                 {
10000                   if (id == ridpointers[(int) RID_INT])
10001                     explicit_int = 1;
10002                   else if (id == ridpointers[(int) RID_CHAR])
10003                     explicit_char = 1;
10004                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10005                 }
10006               goto found;
10007             }
10008           /* C++ aggregate types.  */
10009           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10010             {
10011               if (type)
10012                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10013               else
10014                 type = IDENTIFIER_TYPE_VALUE (id);
10015               goto found;
10016             }
10017
10018           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10019             {
10020               if (ridpointers[i] == id)
10021                 {
10022                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10023                     {
10024                       if (pedantic && ! in_system_header && warn_long_long)
10025                         pedwarn ("ISO C++ does not support `long long'");
10026                       if (longlong)
10027                         error ("`long long long' is too long for GCC");
10028                       else
10029                         longlong = 1;
10030                     }
10031                   else if (RIDBIT_SETP (i, specbits))
10032                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10033                   RIDBIT_SET (i, specbits);
10034                   goto found;
10035                 }
10036             }
10037         }
10038       /* C++ aggregate types.  */
10039       else if (TREE_CODE (id) == TYPE_DECL)
10040         {
10041           if (type)
10042             cp_error ("multiple declarations `%T' and `%T'", type,
10043                       TREE_TYPE (id));
10044           else
10045             {
10046               type = TREE_TYPE (id);
10047               TREE_VALUE (spec) = type;
10048             }
10049           goto found;
10050         }
10051       if (type)
10052         error ("two or more data types in declaration of `%s'", name);
10053       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10054         {
10055           register tree t = lookup_name (id, 1);
10056           if (!t || TREE_CODE (t) != TYPE_DECL)
10057             error ("`%s' fails to be a typedef or built in type",
10058                    IDENTIFIER_POINTER (id));
10059           else
10060             {
10061               type = TREE_TYPE (t);
10062 #if 0
10063               /* See the code below that used this.  */
10064               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10065 #endif
10066               typedef_decl = t;
10067             }
10068         }
10069       else if (id != error_mark_node)
10070         /* Can't change CLASS nodes into RECORD nodes here!  */
10071         type = id;
10072
10073     found: ;
10074     }
10075
10076   typedef_type = type;
10077
10078   /* No type at all: default to `int', and set DEFAULTED_INT
10079      because it was not a user-defined typedef.  */
10080
10081   if (type == NULL_TREE
10082       && (RIDBIT_SETP (RID_SIGNED, specbits)
10083           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10084           || RIDBIT_SETP (RID_LONG, specbits)
10085           || RIDBIT_SETP (RID_SHORT, specbits)))
10086     {
10087       /* These imply 'int'.  */
10088       type = integer_type_node;
10089       defaulted_int = 1;
10090     }
10091
10092   if (sfk != sfk_none)
10093     type = check_special_function_return_type (sfk, type,
10094                                                ctor_return_type,
10095                                                ctor_return_type);
10096   else if (type == NULL_TREE)
10097     {
10098       int is_main;
10099
10100       explicit_int = -1;
10101
10102           /* We handle `main' specially here, because 'main () { }' is so
10103              common.  With no options, it is allowed.  With -Wreturn-type,
10104              it is a warning.  It is only an error with -pedantic-errors.  */
10105       is_main = (funcdef_flag
10106                  && MAIN_NAME_P (dname)
10107                  && ctype == NULL_TREE
10108                  && in_namespace == NULL_TREE
10109                  && current_namespace == global_namespace);
10110
10111       if (in_system_header || flag_ms_extensions)
10112         /* Allow it, sigh.  */;
10113       else if (pedantic || ! is_main)
10114         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10115                     name);
10116       else if (warn_return_type)
10117         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10118                     name);
10119
10120       type = integer_type_node;
10121     }
10122
10123   ctype = NULL_TREE;
10124
10125   /* Now process the modifiers that were specified
10126      and check for invalid combinations.  */
10127
10128   /* Long double is a special combination.  */
10129
10130   if (RIDBIT_SETP (RID_LONG, specbits)
10131       && TYPE_MAIN_VARIANT (type) == double_type_node)
10132     {
10133       RIDBIT_RESET (RID_LONG, specbits);
10134       type = build_qualified_type (long_double_type_node,
10135                                    CP_TYPE_QUALS (type));
10136     }
10137
10138   /* Check all other uses of type modifiers.  */
10139
10140   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10141       || RIDBIT_SETP (RID_SIGNED, specbits)
10142       || RIDBIT_SETP (RID_LONG, specbits)
10143       || RIDBIT_SETP (RID_SHORT, specbits))
10144     {
10145       int ok = 0;
10146
10147       if (TREE_CODE (type) == REAL_TYPE)
10148         error ("short, signed or unsigned invalid for `%s'", name);
10149       else if (TREE_CODE (type) != INTEGER_TYPE)
10150         error ("long, short, signed or unsigned invalid for `%s'", name);
10151       else if (RIDBIT_SETP (RID_LONG, specbits)
10152                && RIDBIT_SETP (RID_SHORT, specbits))
10153         error ("long and short specified together for `%s'", name);
10154       else if ((RIDBIT_SETP (RID_LONG, specbits)
10155                 || RIDBIT_SETP (RID_SHORT, specbits))
10156                && explicit_char)
10157         error ("long or short specified with char for `%s'", name);
10158       else if ((RIDBIT_SETP (RID_LONG, specbits)
10159                 || RIDBIT_SETP (RID_SHORT, specbits))
10160                && TREE_CODE (type) == REAL_TYPE)
10161         error ("long or short specified with floating type for `%s'", name);
10162       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10163                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10164         error ("signed and unsigned given together for `%s'", name);
10165       else
10166         {
10167           ok = 1;
10168           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10169             {
10170               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10171                        name);
10172               if (flag_pedantic_errors)
10173                 ok = 0;
10174             }
10175         }
10176
10177       /* Discard the type modifiers if they are invalid.  */
10178       if (! ok)
10179         {
10180           RIDBIT_RESET (RID_UNSIGNED, specbits);
10181           RIDBIT_RESET (RID_SIGNED, specbits);
10182           RIDBIT_RESET (RID_LONG, specbits);
10183           RIDBIT_RESET (RID_SHORT, specbits);
10184           longlong = 0;
10185         }
10186     }
10187
10188   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10189       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10190     {
10191       error ("complex invalid for `%s'", name);
10192       RIDBIT_RESET (RID_COMPLEX, specbits);
10193     }
10194
10195   /* Decide whether an integer type is signed or not.
10196      Optionally treat bitfields as signed by default.  */
10197   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10198       /* [class.bit]
10199
10200          It is implementation-defined whether a plain (neither
10201          explicitly signed or unsigned) char, short, int, or long
10202          bit-field is signed or unsigned.
10203
10204          Naturally, we extend this to long long as well.  Note that
10205          this does not include wchar_t.  */
10206       || (bitfield && !flag_signed_bitfields
10207           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10208           /* A typedef for plain `int' without `signed' can be
10209              controlled just like plain `int', but a typedef for
10210              `signed int' cannot be so controlled.  */
10211           && !(typedef_decl
10212                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10213           && (TREE_CODE (type) == INTEGER_TYPE
10214               || TREE_CODE (type) == CHAR_TYPE)
10215           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10216     {
10217       if (longlong)
10218         type = long_long_unsigned_type_node;
10219       else if (RIDBIT_SETP (RID_LONG, specbits))
10220         type = long_unsigned_type_node;
10221       else if (RIDBIT_SETP (RID_SHORT, specbits))
10222         type = short_unsigned_type_node;
10223       else if (type == char_type_node)
10224         type = unsigned_char_type_node;
10225       else if (typedef_decl)
10226         type = unsigned_type (type);
10227       else
10228         type = unsigned_type_node;
10229     }
10230   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10231            && type == char_type_node)
10232     type = signed_char_type_node;
10233   else if (longlong)
10234     type = long_long_integer_type_node;
10235   else if (RIDBIT_SETP (RID_LONG, specbits))
10236     type = long_integer_type_node;
10237   else if (RIDBIT_SETP (RID_SHORT, specbits))
10238     type = short_integer_type_node;
10239
10240   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10241     {
10242       /* If we just have "complex", it is equivalent to
10243          "complex double", but if any modifiers at all are specified it is
10244          the complex form of TYPE.  E.g, "complex short" is
10245          "complex short int".  */
10246
10247       if (defaulted_int && ! longlong
10248           && ! (RIDBIT_SETP (RID_LONG, specbits)
10249                 || RIDBIT_SETP (RID_SHORT, specbits)
10250                 || RIDBIT_SETP (RID_SIGNED, specbits)
10251                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10252         type = complex_double_type_node;
10253       else if (type == integer_type_node)
10254         type = complex_integer_type_node;
10255       else if (type == float_type_node)
10256         type = complex_float_type_node;
10257       else if (type == double_type_node)
10258         type = complex_double_type_node;
10259       else if (type == long_double_type_node)
10260         type = complex_long_double_type_node;
10261       else
10262         type = build_complex_type (type);
10263     }
10264
10265   if (sfk == sfk_conversion
10266       && (RIDBIT_SETP (RID_CONST, specbits)
10267           || RIDBIT_SETP (RID_VOLATILE, specbits)
10268           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10269     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10270               ctor_return_type);
10271
10272   /* Set CONSTP if this declaration is `const', whether by
10273      explicit specification or via a typedef.
10274      Likewise for VOLATILEP.  */
10275
10276   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10277   restrictp =
10278     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10279   volatilep =
10280     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10281   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10282                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10283                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10284   type = cp_build_qualified_type (type, type_quals);
10285   staticp = 0;
10286   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10287   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10288   RIDBIT_RESET (RID_VIRTUAL, specbits);
10289   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10290   RIDBIT_RESET (RID_EXPLICIT, specbits);
10291
10292   if (RIDBIT_SETP (RID_STATIC, specbits))
10293     staticp = 1 + (decl_context == FIELD);
10294
10295   if (virtualp && staticp == 2)
10296     {
10297       cp_error ("member `%D' cannot be declared both virtual and static",
10298                 dname);
10299       staticp = 0;
10300     }
10301   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10302   RIDBIT_RESET (RID_FRIEND, specbits);
10303
10304   /* Warn if two storage classes are given. Default to `auto'.  */
10305
10306   if (RIDBIT_ANY_SET (specbits))
10307     {
10308       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10309       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10310       if (decl_context == PARM && nclasses > 0)
10311         error ("storage class specifiers invalid in parameter declarations");
10312       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10313         {
10314           if (decl_context == PARM)
10315             error ("typedef declaration invalid in parameter declaration");
10316           nclasses++;
10317         }
10318       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10319       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10320     }
10321
10322   /* Give error if `virtual' is used outside of class declaration.  */
10323   if (virtualp
10324       && (current_class_name == NULL_TREE || decl_context != FIELD))
10325     {
10326       error ("virtual outside class declaration");
10327       virtualp = 0;
10328     }
10329
10330   /* Static anonymous unions are dealt with here.  */
10331   if (staticp && decl_context == TYPENAME
10332       && TREE_CODE (declspecs) == TREE_LIST
10333       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10334     decl_context = FIELD;
10335
10336   /* Warn about storage classes that are invalid for certain
10337      kinds of declarations (parameters, typenames, etc.).  */
10338
10339   if (nclasses > 1)
10340     error ("multiple storage classes in declaration of `%s'", name);
10341   else if (decl_context != NORMAL && nclasses > 0)
10342     {
10343       if ((decl_context == PARM || decl_context == CATCHPARM)
10344           && (RIDBIT_SETP (RID_REGISTER, specbits)
10345               || RIDBIT_SETP (RID_AUTO, specbits)))
10346         ;
10347       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10348         ;
10349       else if (decl_context == FIELD
10350                /* C++ allows static class elements  */
10351                && RIDBIT_SETP (RID_STATIC, specbits))
10352         /* C++ also allows inlines and signed and unsigned elements,
10353            but in those cases we don't come in here.  */
10354         ;
10355       else
10356         {
10357           if (decl_context == FIELD)
10358             {
10359               tree tmp = NULL_TREE;
10360               register int op = 0;
10361
10362               if (declarator)
10363                 {
10364                   /* Avoid trying to get an operand off an identifier node.  */
10365                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10366                     tmp = declarator;
10367                   else
10368                     tmp = TREE_OPERAND (declarator, 0);
10369                   op = IDENTIFIER_OPNAME_P (tmp);
10370                   if (IDENTIFIER_TYPENAME_P (tmp))
10371                     {
10372                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10373                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10374                               == TYPE_DECL))
10375                         name = IDENTIFIER_POINTER (tmp);
10376                       else
10377                         name = "<invalid operator>";
10378                     }
10379                 }
10380               error ("storage class specified for %s `%s'",
10381                      op ? "member operator" : "field",
10382                      name);
10383             }
10384           else
10385             {
10386               if (decl_context == PARM || decl_context == CATCHPARM)
10387                 error ("storage class specified for parameter `%s'", name);
10388               else
10389                 error ("storage class specified for typename");
10390             }
10391           RIDBIT_RESET (RID_REGISTER, specbits);
10392           RIDBIT_RESET (RID_AUTO, specbits);
10393           RIDBIT_RESET (RID_EXTERN, specbits);
10394         }
10395     }
10396   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10397     {
10398       if (toplevel_bindings_p ())
10399         {
10400           /* It's common practice (and completely valid) to have a const
10401              be initialized and declared extern.  */
10402           if (!(type_quals & TYPE_QUAL_CONST))
10403             warning ("`%s' initialized and declared `extern'", name);
10404         }
10405       else
10406         error ("`%s' has both `extern' and initializer", name);
10407     }
10408   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10409            && ! toplevel_bindings_p ())
10410     error ("nested function `%s' declared `extern'", name);
10411   else if (toplevel_bindings_p ())
10412     {
10413       if (RIDBIT_SETP (RID_AUTO, specbits))
10414         error ("top-level declaration of `%s' specifies `auto'", name);
10415     }
10416
10417   if (nclasses > 0 && friendp)
10418     error ("storage class specifiers invalid in friend function declarations");
10419
10420   /* Now figure out the structure of the declarator proper.
10421      Descend through it, creating more complex types, until we reach
10422      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10423
10424   inner_attrs = NULL_TREE;
10425   ignore_attrs = 0;
10426
10427   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10428          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10429     {
10430       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10431          an INDIRECT_REF (for *...),
10432          a CALL_EXPR (for ...(...)),
10433          an identifier (for the name being declared)
10434          or a null pointer (for the place in an absolute declarator
10435          where the name was omitted).
10436          For the last two cases, we have just exited the loop.
10437
10438          For C++ it could also be
10439          a SCOPE_REF (for class :: ...).  In this case, we have converted
10440          sensible names to types, and those are the values we use to
10441          qualify the member name.
10442          an ADDR_EXPR (for &...),
10443          a BIT_NOT_EXPR (for destructors)
10444
10445          At this point, TYPE is the type of elements of an array,
10446          or for a function to return, or for a pointer to point to.
10447          After this sequence of ifs, TYPE is the type of the
10448          array or function or pointer, and DECLARATOR has had its
10449          outermost layer removed.  */
10450
10451       if (type == error_mark_node)
10452         {
10453           if (TREE_CODE (declarator) == SCOPE_REF)
10454             declarator = TREE_OPERAND (declarator, 1);
10455           else
10456             declarator = TREE_OPERAND (declarator, 0);
10457           continue;
10458         }
10459       if (quals != NULL_TREE
10460           && (declarator == NULL_TREE
10461               || TREE_CODE (declarator) != SCOPE_REF))
10462         {
10463           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10464             ctype = TYPE_METHOD_BASETYPE (type);
10465           if (ctype != NULL_TREE)
10466             {
10467               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10468               grok_method_quals (ctype, dummy, quals);
10469               type = TREE_TYPE (dummy);
10470               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10471               quals = NULL_TREE;
10472             }
10473         }
10474
10475       /* See the comment for the TREE_LIST case, below.  */
10476       if (ignore_attrs)
10477         ignore_attrs = 0;
10478       else if (inner_attrs)
10479         {
10480           decl_attributes (type, inner_attrs, NULL_TREE);
10481           inner_attrs = NULL_TREE;
10482         }
10483
10484       switch (TREE_CODE (declarator))
10485         {
10486         case TREE_LIST:
10487           {
10488             /* We encode a declarator with embedded attributes using
10489                a TREE_LIST.  The attributes apply to the declarator
10490                directly inside them, so we have to skip an iteration
10491                before applying them to the type.  If the declarator just
10492                inside is the declarator-id, we apply the attrs to the
10493                decl itself.  */
10494             inner_attrs = TREE_PURPOSE (declarator);
10495             ignore_attrs = 1;
10496             declarator = TREE_VALUE (declarator);
10497           }
10498           break;
10499
10500         case ARRAY_REF:
10501           {
10502             register tree size;
10503
10504             size = TREE_OPERAND (declarator, 1);
10505
10506             /* VC++ spells a zero-sized array with [].  */
10507             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10508                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10509               size = integer_zero_node;
10510
10511             declarator = TREE_OPERAND (declarator, 0);
10512
10513             type = create_array_type_for_decl (dname, type, size);
10514
10515             /* VLAs never work as fields. */
10516             if (decl_context == FIELD && !processing_template_decl
10517                 && TREE_CODE (type) == ARRAY_TYPE
10518                 && TYPE_DOMAIN (type) != NULL_TREE
10519                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10520               {
10521                 cp_error ("size of member `%D' is not constant", dname);
10522                 /* Proceed with arbitrary constant size, so that offset
10523                    computations don't get confused. */
10524                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10525                                                    integer_one_node);
10526               }
10527
10528             ctype = NULL_TREE;
10529           }
10530           break;
10531
10532         case CALL_EXPR:
10533           {
10534             tree arg_types;
10535             int funcdecl_p;
10536             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10537             tree inner_decl = TREE_OPERAND (declarator, 0);
10538
10539             /* Declaring a function type.
10540                Make sure we have a valid type for the function to return.  */
10541
10542             /* We now know that the TYPE_QUALS don't apply to the
10543                decl, but to its return type.  */
10544             type_quals = TYPE_UNQUALIFIED;
10545
10546             /* Warn about some types functions can't return.  */
10547
10548             if (TREE_CODE (type) == FUNCTION_TYPE)
10549               {
10550                 error ("`%s' declared as function returning a function", name);
10551                 type = integer_type_node;
10552               }
10553             if (TREE_CODE (type) == ARRAY_TYPE)
10554               {
10555                 error ("`%s' declared as function returning an array", name);
10556                 type = integer_type_node;
10557               }
10558
10559             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10560               inner_decl = TREE_OPERAND (inner_decl, 1);
10561
10562             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10563               inner_decl = dname;
10564
10565             /* Pick up type qualifiers which should be applied to `this'.  */
10566             quals = CALL_DECLARATOR_QUALS (declarator);
10567
10568             /* Pick up the exception specifications.  */
10569             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10570
10571             /* Say it's a definition only for the CALL_EXPR
10572                closest to the identifier.  */
10573             funcdecl_p
10574               = inner_decl
10575               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10576                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10577                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10578
10579             if (ctype == NULL_TREE
10580                 && decl_context == FIELD
10581                 && funcdecl_p
10582                 && (friendp == 0 || dname == current_class_name))
10583               ctype = current_class_type;
10584
10585             if (ctype && sfk == sfk_conversion)
10586               TYPE_HAS_CONVERSION (ctype) = 1;
10587             if (ctype && constructor_name (ctype) == dname)
10588               {
10589                 /* We are within a class's scope. If our declarator name
10590                    is the same as the class name, and we are defining
10591                    a function, then it is a constructor/destructor, and
10592                    therefore returns a void type.  */
10593
10594                 if (flags == DTOR_FLAG)
10595                   {
10596                     /* ISO C++ 12.4/2.  A destructor may not be
10597                        declared const or volatile.  A destructor may
10598                        not be static.  */
10599                     if (staticp == 2)
10600                       error ("destructor cannot be static member function");
10601                     if (quals)
10602                       {
10603                         cp_error ("destructors may not be `%s'",
10604                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10605                         quals = NULL_TREE;
10606                       }
10607                     if (decl_context == FIELD)
10608                       {
10609                         if (! member_function_or_else (ctype,
10610                                                        current_class_type,
10611                                                        flags))
10612                           return void_type_node;
10613                       }
10614                   }
10615                 else            /* It's a constructor.  */
10616                   {
10617                     if (explicitp == 1)
10618                       explicitp = 2;
10619                     /* ISO C++ 12.1.  A constructor may not be
10620                        declared const or volatile.  A constructor may
10621                        not be virtual.  A constructor may not be
10622                        static.  */
10623                     if (staticp == 2)
10624                       error ("constructor cannot be static member function");
10625                     if (virtualp)
10626                       {
10627                         pedwarn ("constructors cannot be declared virtual");
10628                         virtualp = 0;
10629                       }
10630                     if (quals)
10631                       {
10632                         cp_error ("constructors may not be `%s'",
10633                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10634                         quals = NULL_TREE;
10635                       }
10636                     {
10637                       RID_BIT_TYPE tmp_bits;
10638                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10639                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10640                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10641                       if (RIDBIT_ANY_SET (tmp_bits))
10642                         error ("return value type specifier for constructor ignored");
10643                     }
10644                     if (decl_context == FIELD)
10645                       {
10646                         if (! member_function_or_else (ctype,
10647                                                        current_class_type,
10648                                                        flags))
10649                           return void_type_node;
10650                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10651                         if (sfk != sfk_constructor)
10652                           return NULL_TREE;
10653                       }
10654                   }
10655                 if (decl_context == FIELD)
10656                   staticp = 0;
10657               }
10658             else if (friendp)
10659               {
10660                 if (initialized)
10661                   error ("can't initialize friend function `%s'", name);
10662                 if (virtualp)
10663                   {
10664                     /* Cannot be both friend and virtual.  */
10665                     error ("virtual functions cannot be friends");
10666                     RIDBIT_RESET (RID_FRIEND, specbits);
10667                     friendp = 0;
10668                   }
10669                 if (decl_context == NORMAL)
10670                   error ("friend declaration not in class definition");
10671                 if (current_function_decl && funcdef_flag)
10672                   cp_error ("can't define friend function `%s' in a local class definition",
10673                             name);
10674               }
10675
10676             /* Construct the function type and go to the next
10677                inner layer of declarator.  */
10678
10679             declarator = TREE_OPERAND (declarator, 0);
10680
10681             /* FIXME: This is where default args should be fully
10682                processed.  */
10683
10684             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10685
10686             if (declarator && flags == DTOR_FLAG)
10687               {
10688                 /* A destructor declared in the body of a class will
10689                    be represented as a BIT_NOT_EXPR.  But, we just
10690                    want the underlying IDENTIFIER.  */
10691                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10692                   declarator = TREE_OPERAND (declarator, 0);
10693
10694                 if (arg_types != void_list_node)
10695                   {
10696                     cp_error ("destructors may not have parameters");
10697                     arg_types = void_list_node;
10698                     last_function_parms = NULL_TREE;
10699                   }
10700               }
10701
10702             /* ANSI says that `const int foo ();'
10703                does not make the function foo const.  */
10704             type = build_function_type (type, arg_types);
10705
10706             {
10707               tree t;
10708               for (t = arg_types; t; t = TREE_CHAIN (t))
10709                 if (TREE_PURPOSE (t)
10710                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10711                   {
10712                     add_defarg_fn (type);
10713                     break;
10714                   }
10715             }
10716           }
10717           break;
10718
10719         case ADDR_EXPR:
10720         case INDIRECT_REF:
10721           /* Filter out pointers-to-references and references-to-references.
10722              We can get these if a TYPE_DECL is used.  */
10723
10724           if (TREE_CODE (type) == REFERENCE_TYPE)
10725             {
10726               error ("cannot declare %s to references",
10727                      TREE_CODE (declarator) == ADDR_EXPR
10728                      ? "references" : "pointers");
10729               declarator = TREE_OPERAND (declarator, 0);
10730               continue;
10731             }
10732
10733           if (TREE_CODE (type) == OFFSET_TYPE
10734               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10735                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10736             {
10737               cp_error ("cannot declare pointer to `%#T' member",
10738                         TREE_TYPE (type));
10739               type = TREE_TYPE (type);
10740             }
10741
10742           /* Merge any constancy or volatility into the target type
10743              for the pointer.  */
10744
10745           /* We now know that the TYPE_QUALS don't apply to the decl,
10746              but to the target of the pointer.  */
10747           type_quals = TYPE_UNQUALIFIED;
10748
10749           if (TREE_CODE (declarator) == ADDR_EXPR)
10750             {
10751               if (TREE_CODE (type) == VOID_TYPE)
10752                 error ("invalid type: `void &'");
10753               else
10754                 type = build_reference_type (type);
10755             }
10756           else if (TREE_CODE (type) == METHOD_TYPE)
10757             type = build_ptrmemfunc_type (build_pointer_type (type));
10758           else
10759             type = build_pointer_type (type);
10760
10761           /* Process a list of type modifier keywords (such as
10762              const or volatile) that were given inside the `*' or `&'.  */
10763
10764           if (TREE_TYPE (declarator))
10765             {
10766               register tree typemodlist;
10767               int erred = 0;
10768
10769               constp = 0;
10770               volatilep = 0;
10771               restrictp = 0;
10772               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10773                    typemodlist = TREE_CHAIN (typemodlist))
10774                 {
10775                   tree qualifier = TREE_VALUE (typemodlist);
10776
10777                   if (qualifier == ridpointers[(int) RID_CONST])
10778                     constp++;
10779                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10780                     volatilep++;
10781                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10782                     restrictp++;
10783                   else if (!erred)
10784                     {
10785                       erred = 1;
10786                       error ("invalid type modifier within pointer declarator");
10787                     }
10788                 }
10789               if (constp > 1)
10790                 pedwarn ("duplicate `const'");
10791               if (volatilep > 1)
10792                 pedwarn ("duplicate `volatile'");
10793               if (restrictp > 1)
10794                 pedwarn ("duplicate `restrict'");
10795
10796               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10797                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10798                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10799               if (TREE_CODE (declarator) == ADDR_EXPR
10800                   && (constp || volatilep))
10801                 {
10802                   if (constp)
10803                     pedwarn ("discarding `const' applied to a reference");
10804                   if (volatilep)
10805                     pedwarn ("discarding `volatile' applied to a reference");
10806                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10807                 }
10808               type = cp_build_qualified_type (type, type_quals);
10809             }
10810           declarator = TREE_OPERAND (declarator, 0);
10811           ctype = NULL_TREE;
10812           break;
10813
10814         case SCOPE_REF:
10815           {
10816             /* We have converted type names to NULL_TREE if the
10817                name was bogus, or to a _TYPE node, if not.
10818
10819                The variable CTYPE holds the type we will ultimately
10820                resolve to.  The code here just needs to build
10821                up appropriate member types.  */
10822             tree sname = TREE_OPERAND (declarator, 1);
10823             tree t;
10824
10825             /* Destructors can have their visibilities changed as well.  */
10826             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10827               sname = TREE_OPERAND (sname, 0);
10828
10829             if (TREE_COMPLEXITY (declarator) == 0)
10830               /* This needs to be here, in case we are called
10831                  multiple times.  */ ;
10832             else if (TREE_COMPLEXITY (declarator) == -1)
10833               /* Namespace member. */
10834               pop_decl_namespace ();
10835             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10836               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10837             else if (! IS_AGGR_TYPE_CODE
10838                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10839               ;
10840             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10841               {
10842                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10843                    that refer to ctype.  They couldn't be resolved earlier
10844                    because we hadn't pushed into the class yet.
10845                    Example: resolve 'B<T>::type' in
10846                    'B<typename B<T>::type> B<T>::f () { }'.  */
10847                 if (current_template_parms
10848                     && uses_template_parms (type)
10849                     && uses_template_parms (current_class_type))
10850                   {
10851                     tree args = current_template_args ();
10852                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10853                   }
10854
10855                 /* This pop_nested_class corresponds to the
10856                    push_nested_class used to push into class scope for
10857                    parsing the argument list of a function decl, in
10858                    qualified_id.  */
10859                 pop_nested_class ();
10860                 TREE_COMPLEXITY (declarator) = current_class_depth;
10861               }
10862             else
10863               my_friendly_abort (16);
10864
10865             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10866               {
10867                 /* We had a reference to a global decl, or
10868                    perhaps we were given a non-aggregate typedef,
10869                    in which case we cleared this out, and should just
10870                    keep going as though it wasn't there.  */
10871                 declarator = sname;
10872                 continue;
10873               }
10874             ctype = TREE_OPERAND (declarator, 0);
10875
10876             t = ctype;
10877             while (t != NULL_TREE && CLASS_TYPE_P (t))
10878               {
10879                 /* You're supposed to have one `template <...>'
10880                    for every template class, but you don't need one
10881                    for a full specialization.  For example:
10882
10883                      template <class T> struct S{};
10884                      template <> struct S<int> { void f(); };
10885                      void S<int>::f () {}
10886
10887                    is correct; there shouldn't be a `template <>' for
10888                    the definition of `S<int>::f'.  */
10889                 if (CLASSTYPE_TEMPLATE_INFO (t)
10890                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10891                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10892                   template_count += 1;
10893
10894                 t = TYPE_MAIN_DECL (t);
10895                 if (DECL_LANG_SPECIFIC (t))
10896                   t = DECL_CONTEXT (t);
10897                 else
10898                   t = NULL_TREE;
10899               }
10900
10901             if (sname == NULL_TREE)
10902               goto done_scoping;
10903
10904             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10905               {
10906                 /* This is the `standard' use of the scoping operator:
10907                    basetype :: member .  */
10908
10909                 if (ctype == current_class_type)
10910                   {
10911                     /* class A {
10912                          void A::f ();
10913                        };
10914
10915                        Is this ill-formed?  */
10916
10917                     if (pedantic)
10918                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10919                                   ctype, name);
10920                   }
10921                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10922                   {
10923                     if (current_class_type == NULL_TREE
10924                         || friendp)
10925                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10926                                                       TYPE_ARG_TYPES (type));
10927                     else
10928                       {
10929                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10930                                   ctype, name, current_class_type);
10931                         return void_type_node;
10932                       }
10933                   }
10934                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10935                          || COMPLETE_TYPE_P (complete_type (ctype)))
10936                   {
10937                     /* Have to move this code elsewhere in this function.
10938                        this code is used for i.e., typedef int A::M; M *pm;
10939
10940                        It is?  How? jason 10/2/94 */
10941
10942                     if (current_class_type)
10943                       {
10944                         cp_error ("cannot declare member `%T::%s' within `%T'",
10945                                   ctype, name, current_class_type);
10946                         return void_type_node;
10947                       }
10948                     type = build_offset_type (ctype, type);
10949                   }
10950                 else if (uses_template_parms (ctype))
10951                   {
10952                     if (TREE_CODE (type) == FUNCTION_TYPE)
10953                       type
10954                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10955                                                    TYPE_ARG_TYPES (type));
10956                   }
10957                 else
10958                   {
10959                     cp_error ("structure `%T' not yet defined", ctype);
10960                     return error_mark_node;
10961                   }
10962
10963                 declarator = sname;
10964               }
10965             else if (TREE_CODE (sname) == SCOPE_REF)
10966               my_friendly_abort (17);
10967             else
10968               {
10969               done_scoping:
10970                 declarator = TREE_OPERAND (declarator, 1);
10971                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10972                   /* In this case, we will deal with it later.  */
10973                   ;
10974                 else
10975                   {
10976                     if (TREE_CODE (type) == FUNCTION_TYPE)
10977                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10978                                                       TYPE_ARG_TYPES (type));
10979                     else
10980                       type = build_offset_type (ctype, type);
10981                   }
10982               }
10983           }
10984           break;
10985
10986         case BIT_NOT_EXPR:
10987           declarator = TREE_OPERAND (declarator, 0);
10988           break;
10989
10990         case RECORD_TYPE:
10991         case UNION_TYPE:
10992         case ENUMERAL_TYPE:
10993           declarator = NULL_TREE;
10994           break;
10995
10996         case ERROR_MARK:
10997           declarator = NULL_TREE;
10998           break;
10999
11000         default:
11001           my_friendly_abort (158);
11002         }
11003     }
11004
11005   /* See the comment for the TREE_LIST case, above.  */
11006   if (inner_attrs)
11007     {
11008       if (! ignore_attrs)
11009         decl_attributes (type, inner_attrs, NULL_TREE);
11010       else if (attrlist)
11011         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11012       else
11013         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11014     }
11015
11016   /* Now TYPE has the actual type.  */
11017
11018   if (explicitp == 1 || (explicitp && friendp))
11019     {
11020       /* [dcl.fct.spec] The explicit specifier shall only be used in
11021          declarations of constructors within a class definition.  */
11022       error ("only declarations of constructors can be `explicit'");
11023       explicitp = 0;
11024     }
11025
11026   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11027     {
11028       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11029         {
11030           error ("non-member `%s' cannot be declared `mutable'", name);
11031           RIDBIT_RESET (RID_MUTABLE, specbits);
11032         }
11033       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11034         {
11035           error ("non-object member `%s' cannot be declared `mutable'", name);
11036           RIDBIT_RESET (RID_MUTABLE, specbits);
11037         }
11038       else if (TREE_CODE (type) == FUNCTION_TYPE
11039                || TREE_CODE (type) == METHOD_TYPE)
11040         {
11041           error ("function `%s' cannot be declared `mutable'", name);
11042           RIDBIT_RESET (RID_MUTABLE, specbits);
11043         }
11044       else if (staticp)
11045         {
11046           error ("static `%s' cannot be declared `mutable'", name);
11047           RIDBIT_RESET (RID_MUTABLE, specbits);
11048         }
11049       else if (type_quals & TYPE_QUAL_CONST)
11050         {
11051           error ("const `%s' cannot be declared `mutable'", name);
11052           RIDBIT_RESET (RID_MUTABLE, specbits);
11053         }
11054     }
11055
11056   if (declarator == NULL_TREE
11057       || TREE_CODE (declarator) == IDENTIFIER_NODE
11058       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11059           && (TREE_CODE (type) == FUNCTION_TYPE
11060               || TREE_CODE (type) == METHOD_TYPE)))
11061     /* OK */;
11062   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11063     {
11064       cp_error ("template-id `%D' used as a declarator", declarator);
11065       declarator = dname;
11066     }
11067   else
11068     /* Unexpected declarator format.  */
11069     my_friendly_abort (990210);
11070
11071   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11072
11073   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11074     {
11075       tree decl;
11076
11077       /* Note that the grammar rejects storage classes
11078          in typenames, fields or parameters.  */
11079       if (current_lang_name == lang_name_java)
11080         TYPE_FOR_JAVA (type) = 1;
11081
11082       if (decl_context == FIELD)
11083         {
11084           if (declarator == constructor_name (current_class_type))
11085             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11086                         declarator);
11087           decl = build_lang_decl (TYPE_DECL, declarator, type);
11088         }
11089       else
11090         decl = build_decl (TYPE_DECL, declarator, type);
11091
11092       /* If the user declares "typedef struct {...} foo" then the
11093          struct will have an anonymous name.  Fill that name in now.
11094          Nothing can refer to it, so nothing needs know about the name
11095          change.  */
11096       if (type != error_mark_node
11097           && declarator
11098           && TYPE_NAME (type)
11099           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11100           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11101           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11102         {
11103           tree oldname = TYPE_NAME (type);
11104           tree t;
11105
11106           /* Replace the anonymous name with the real name everywhere.  */
11107           lookup_tag_reverse (type, declarator);
11108           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11109             if (TYPE_NAME (t) == oldname)
11110               TYPE_NAME (t) = decl;
11111
11112           if (TYPE_LANG_SPECIFIC (type))
11113             TYPE_WAS_ANONYMOUS (type) = 1;
11114
11115           /* If this is a typedef within a template class, the nested
11116              type is a (non-primary) template.  The name for the
11117              template needs updating as well.  */
11118           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11119             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11120               = TYPE_IDENTIFIER (type);
11121
11122           if (flag_new_abi)
11123             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11124           else
11125             {
11126               /* XXX Temporarily set the scope.
11127                  When returning, start_decl expects it as NULL_TREE,
11128                  and will then then set it using pushdecl. */
11129               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11130               if (current_class_type)
11131                 DECL_CONTEXT (decl) = current_class_type;
11132               else
11133                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11134
11135               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11136               DECL_ASSEMBLER_NAME (decl)
11137                 = get_identifier (build_overload_name (type, 1, 1));
11138               DECL_CONTEXT (decl) = NULL_TREE;
11139             }
11140
11141           /* FIXME remangle member functions; member functions of a
11142              type with external linkage have external linkage.  */
11143         }
11144
11145       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11146         {
11147           cp_error_at ("typedef name may not be class-qualified", decl);
11148           return NULL_TREE;
11149         }
11150       else if (quals)
11151         {
11152           if (ctype == NULL_TREE)
11153             {
11154               if (TREE_CODE (type) != METHOD_TYPE)
11155                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11156               else
11157                 ctype = TYPE_METHOD_BASETYPE (type);
11158             }
11159           if (ctype != NULL_TREE)
11160             grok_method_quals (ctype, decl, quals);
11161         }
11162
11163       if (RIDBIT_SETP (RID_SIGNED, specbits)
11164           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11165         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11166
11167       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11168                       inlinep, friendp, raises != NULL_TREE);
11169
11170       if (initialized)
11171         error ("typedef declaration includes an initializer");
11172
11173       return decl;
11174     }
11175
11176   /* Detect the case of an array type of unspecified size
11177      which came, as such, direct from a typedef name.
11178      We must copy the type, so that each identifier gets
11179      a distinct type, so that each identifier's size can be
11180      controlled separately by its own initializer.  */
11181
11182   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11183       && TYPE_DOMAIN (type) == NULL_TREE)
11184     {
11185       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11186     }
11187
11188   /* If this is a type name (such as, in a cast or sizeof),
11189      compute the type and return it now.  */
11190
11191   if (decl_context == TYPENAME)
11192     {
11193       /* Note that the grammar rejects storage classes
11194          in typenames, fields or parameters.  */
11195       if (type_quals != TYPE_UNQUALIFIED)
11196         type_quals = TYPE_UNQUALIFIED;
11197
11198       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11199       if (friendp)
11200         {
11201           if (type_quals != TYPE_UNQUALIFIED)
11202             {
11203               cp_error ("type qualifiers specified for friend class declaration");
11204               type_quals = TYPE_UNQUALIFIED;
11205             }
11206           if (inlinep)
11207             {
11208               cp_error ("`inline' specified for friend class declaration");
11209               inlinep = 0;
11210             }
11211
11212           /* Only try to do this stuff if we didn't already give up.  */
11213           if (type != integer_type_node)
11214             {
11215               /* A friendly class?  */
11216               if (current_class_type)
11217                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11218               else
11219                 error ("trying to make class `%s' a friend of global scope",
11220                        TYPE_NAME_STRING (type));
11221               type = void_type_node;
11222             }
11223         }
11224       else if (quals)
11225         {
11226           if (ctype == NULL_TREE)
11227             {
11228               if (TREE_CODE (type) != METHOD_TYPE)
11229                 cp_error ("invalid qualifiers on non-member function type");
11230               else
11231                 ctype = TYPE_METHOD_BASETYPE (type);
11232             }
11233           if (ctype)
11234             {
11235               tree dummy = build_decl (TYPE_DECL, declarator, type);
11236               grok_method_quals (ctype, dummy, quals);
11237               type = TREE_TYPE (dummy);
11238             }
11239         }
11240
11241       return type;
11242     }
11243   else if (declarator == NULL_TREE && decl_context != PARM
11244            && decl_context != CATCHPARM
11245            && TREE_CODE (type) != UNION_TYPE
11246            && ! bitfield)
11247     {
11248       cp_error ("abstract declarator `%T' used as declaration", type);
11249       declarator = make_anon_name ();
11250     }
11251
11252   /* `void' at top level (not within pointer)
11253      is allowed only in typedefs or type names.
11254      We don't complain about parms either, but that is because
11255      a better error message can be made later.  */
11256
11257   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11258     {
11259       if (! declarator)
11260         error ("unnamed variable or field declared void");
11261       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11262         {
11263           if (IDENTIFIER_OPNAME_P (declarator))
11264             my_friendly_abort (356);
11265           else
11266             error ("variable or field `%s' declared void", name);
11267         }
11268       else
11269         error ("variable or field declared void");
11270       type = integer_type_node;
11271     }
11272
11273   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11274      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11275
11276   if (decl_context == PARM || decl_context == CATCHPARM)
11277     {
11278       if (ctype || in_namespace)
11279         error ("cannot use `::' in parameter declaration");
11280
11281       /* A parameter declared as an array of T is really a pointer to T.
11282          One declared as a function is really a pointer to a function.
11283          One declared as a member is really a pointer to member.  */
11284
11285       if (TREE_CODE (type) == ARRAY_TYPE)
11286         {
11287           /* Transfer const-ness of array into that of type pointed to.  */
11288           type = build_pointer_type (TREE_TYPE (type));
11289           type_quals = TYPE_UNQUALIFIED;
11290         }
11291       else if (TREE_CODE (type) == FUNCTION_TYPE)
11292         type = build_pointer_type (type);
11293       else if (TREE_CODE (type) == OFFSET_TYPE)
11294         type = build_pointer_type (type);
11295       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11296         {
11297           error ("declaration of `%s' as void", name);
11298           return NULL_TREE;
11299         }
11300     }
11301
11302   {
11303     register tree decl;
11304
11305     if (decl_context == PARM)
11306       {
11307         decl = build_decl (PARM_DECL, declarator, type);
11308
11309         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11310                         inlinep, friendp, raises != NULL_TREE);
11311
11312         /* Compute the type actually passed in the parmlist,
11313            for the case where there is no prototype.
11314            (For example, shorts and chars are passed as ints.)
11315            When there is a prototype, this is overridden later.  */
11316
11317         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11318       }
11319     else if (decl_context == FIELD)
11320       {
11321         if (type == error_mark_node)
11322           {
11323             /* Happens when declaring arrays of sizes which
11324                are error_mark_node, for example.  */
11325             decl = NULL_TREE;
11326           }
11327         else if (in_namespace && !friendp)
11328           {
11329             /* Something like struct S { int N::j; };  */
11330             cp_error ("invalid use of `::'");
11331             decl = NULL_TREE;
11332           }
11333         else if (TREE_CODE (type) == FUNCTION_TYPE)
11334           {
11335             int publicp = 0;
11336             tree function_context;
11337
11338             /* We catch the others as conflicts with the builtin
11339                typedefs.  */
11340             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11341               {
11342                 cp_error ("function `%D' cannot be declared friend",
11343                           declarator);
11344                 friendp = 0;
11345               }
11346
11347             if (friendp == 0)
11348               {
11349                 if (ctype == NULL_TREE)
11350                   ctype = current_class_type;
11351
11352                 if (ctype == NULL_TREE)
11353                   {
11354                     cp_error ("can't make `%D' into a method -- not in a class",
11355                               declarator);
11356                     return void_type_node;
11357                   }
11358
11359                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11360                    ARM 9.5 */
11361                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11362                   {
11363                     cp_error ("function `%D' declared virtual inside a union",
11364                               declarator);
11365                     return void_type_node;
11366                   }
11367
11368                 if (declarator == ansi_opname (NEW_EXPR)
11369                     || declarator == ansi_opname (VEC_NEW_EXPR)
11370                     || declarator == ansi_opname (DELETE_EXPR)
11371                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11372                   {
11373                     if (virtualp)
11374                       {
11375                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11376                                   declarator);
11377                         virtualp = 0;
11378                       }
11379                   }
11380                 else if (staticp < 2)
11381                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11382                                                   TYPE_ARG_TYPES (type));
11383               }
11384
11385             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11386             function_context = (ctype != NULL_TREE) ?
11387               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11388             publicp = (! friendp || ! staticp)
11389               && function_context == NULL_TREE;
11390             decl = grokfndecl (ctype, type,
11391                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11392                                ? declarator : dname,
11393                                declarator,
11394                                virtualp, flags, quals, raises,
11395                                friendp ? -1 : 0, friendp, publicp, inlinep,
11396                                funcdef_flag, template_count, in_namespace);
11397             if (decl == NULL_TREE)
11398               return decl;
11399 #if 0
11400             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11401             /* The decl and setting of decl_machine_attr is also turned off.  */
11402             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11403 #endif
11404
11405             /* [class.conv.ctor]
11406
11407                A constructor declared without the function-specifier
11408                explicit that can be called with a single parameter
11409                specifies a conversion from the type of its first
11410                parameter to the type of its class.  Such a constructor
11411                is called a converting constructor.  */
11412             if (explicitp == 2)
11413               DECL_NONCONVERTING_P (decl) = 1;
11414             else if (DECL_CONSTRUCTOR_P (decl))
11415               {
11416                 /* The constructor can be called with exactly one
11417                    parameter if there is at least one parameter, and
11418                    any subsequent parameters have default arguments.
11419                    We don't look at the first parameter, which is
11420                    really just the `this' parameter for the new
11421                    object.  */
11422                 tree arg_types =
11423                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11424
11425                 /* Skip the `in_chrg' argument too, if present.  */
11426                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11427                   arg_types = TREE_CHAIN (arg_types);
11428
11429                 if (arg_types == void_list_node
11430                     || (arg_types
11431                         && TREE_CHAIN (arg_types)
11432                         && TREE_CHAIN (arg_types) != void_list_node
11433                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11434                   DECL_NONCONVERTING_P (decl) = 1;
11435               }
11436           }
11437         else if (TREE_CODE (type) == METHOD_TYPE)
11438           {
11439             /* We only get here for friend declarations of
11440                members of other classes.  */
11441             /* All method decls are public, so tell grokfndecl to set
11442                TREE_PUBLIC, also.  */
11443             decl = grokfndecl (ctype, type, declarator, declarator,
11444                                virtualp, flags, quals, raises,
11445                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11446                                template_count, in_namespace);
11447             if (decl == NULL_TREE)
11448               return NULL_TREE;
11449           }
11450         else if (!staticp && ! processing_template_decl
11451                  && !COMPLETE_TYPE_P (complete_type (type))
11452                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11453           {
11454             if (declarator)
11455               cp_error ("field `%D' has incomplete type", declarator);
11456             else
11457               cp_error ("name `%T' has incomplete type", type);
11458
11459             /* If we're instantiating a template, tell them which
11460                instantiation made the field's type be incomplete.  */
11461             if (current_class_type
11462                 && TYPE_NAME (current_class_type)
11463                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11464                 && declspecs && TREE_VALUE (declspecs)
11465                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11466               cp_error ("  in instantiation of template `%T'",
11467                         current_class_type);
11468
11469             type = error_mark_node;
11470             decl = NULL_TREE;
11471           }
11472         else
11473           {
11474             if (friendp)
11475               {
11476                 error ("`%s' is neither function nor member function; cannot be declared friend",
11477                        IDENTIFIER_POINTER (declarator));
11478                 friendp = 0;
11479               }
11480             decl = NULL_TREE;
11481           }
11482
11483         if (friendp)
11484           {
11485             /* Friends are treated specially.  */
11486             if (ctype == current_class_type)
11487               warning ("member functions are implicitly friends of their class");
11488             else
11489               {
11490                 tree t = NULL_TREE;
11491                 if (decl && DECL_NAME (decl))
11492                   {
11493                     if (template_class_depth (current_class_type) == 0)
11494                       {
11495                         decl
11496                           = check_explicit_specialization
11497                           (declarator, decl,
11498                            template_count, 2 * (funcdef_flag != 0) + 4);
11499                         if (decl == error_mark_node)
11500                           return error_mark_node;
11501                       }
11502
11503                     t = do_friend (ctype, declarator, decl,
11504                                    last_function_parms, attrlist, flags, quals,
11505                                    funcdef_flag);
11506                   }
11507                 if (t && funcdef_flag)
11508                   return t;
11509
11510                 return void_type_node;
11511               }
11512           }
11513
11514         /* Structure field.  It may not be a function, except for C++ */
11515
11516         if (decl == NULL_TREE)
11517           {
11518             if (initialized)
11519               {
11520                 if (!staticp)
11521                   {
11522                     /* An attempt is being made to initialize a non-static
11523                        member.  But, from [class.mem]:
11524
11525                        4 A member-declarator can contain a
11526                        constant-initializer only if it declares a static
11527                        member (_class.static_) of integral or enumeration
11528                        type, see _class.static.data_.
11529
11530                        This used to be relatively common practice, but
11531                        the rest of the compiler does not correctly
11532                        handle the initialization unless the member is
11533                        static so we make it static below.  */
11534                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11535                                 declarator);
11536                     cp_pedwarn ("making `%D' static", declarator);
11537                     staticp = 1;
11538                   }
11539
11540                 if (uses_template_parms (type))
11541                   /* We'll check at instantiation time.  */
11542                   ;
11543                 else if (check_static_variable_definition (declarator,
11544                                                            type))
11545                   /* If we just return the declaration, crashes
11546                      will sometimes occur.  We therefore return
11547                      void_type_node, as if this was a friend
11548                      declaration, to cause callers to completely
11549                      ignore this declaration.  */
11550                   return void_type_node;
11551               }
11552
11553             /* 9.2p13 [class.mem] */
11554             if (declarator == constructor_name (current_class_type)
11555                 /* The standard does not allow non-static data members
11556                    here either, but we agreed at the 10/99 meeting
11557                    to change that in TC 1 so that they are allowed in
11558                    classes with no user-defined constructors.  */
11559                 && staticp)
11560               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11561                           declarator);
11562
11563             if (staticp)
11564               {
11565                 /* C++ allows static class members.  All other work
11566                    for this is done by grokfield.  */
11567                 decl = build_lang_decl (VAR_DECL, declarator, type);
11568                 TREE_STATIC (decl) = 1;
11569                 /* In class context, 'static' means public access.  */
11570                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11571               }
11572             else
11573               {
11574                 decl = build_decl (FIELD_DECL, declarator, type);
11575                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11576                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11577                   {
11578                     DECL_MUTABLE_P (decl) = 1;
11579                     RIDBIT_RESET (RID_MUTABLE, specbits);
11580                   }
11581               }
11582
11583             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11584                             inlinep, friendp, raises != NULL_TREE);
11585           }
11586       }
11587     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11588       {
11589         tree original_name;
11590         int publicp = 0;
11591
11592         if (! declarator)
11593           return NULL_TREE;
11594
11595         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11596           original_name = dname;
11597         else
11598           original_name = declarator;
11599
11600         if (RIDBIT_SETP (RID_AUTO, specbits))
11601           error ("storage class `auto' invalid for function `%s'", name);
11602         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11603           error ("storage class `register' invalid for function `%s'", name);
11604
11605         /* Function declaration not at top level.
11606            Storage classes other than `extern' are not allowed
11607            and `extern' makes no difference.  */
11608         if (! toplevel_bindings_p ()
11609             && (RIDBIT_SETP (RID_STATIC, specbits)
11610                 || RIDBIT_SETP (RID_INLINE, specbits))
11611             && pedantic)
11612           {
11613             if (RIDBIT_SETP (RID_STATIC, specbits))
11614               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11615             else
11616               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11617           }
11618
11619         if (ctype == NULL_TREE)
11620           {
11621             if (virtualp)
11622               {
11623                 error ("virtual non-class function `%s'", name);
11624                 virtualp = 0;
11625               }
11626           }
11627         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11628           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11629                                           TYPE_ARG_TYPES (type));
11630
11631         /* Record presence of `static'.  */
11632         publicp = (ctype != NULL_TREE
11633                    || RIDBIT_SETP (RID_EXTERN, specbits)
11634                    || !RIDBIT_SETP (RID_STATIC, specbits));
11635
11636         decl = grokfndecl (ctype, type, original_name, declarator,
11637                            virtualp, flags, quals, raises,
11638                            1, friendp,
11639                            publicp, inlinep, funcdef_flag,
11640                            template_count, in_namespace);
11641         if (decl == NULL_TREE)
11642           return NULL_TREE;
11643
11644         if (staticp == 1)
11645           {
11646             int illegal_static = 0;
11647
11648             /* Don't allow a static member function in a class, and forbid
11649                declaring main to be static.  */
11650             if (TREE_CODE (type) == METHOD_TYPE)
11651               {
11652                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11653                 illegal_static = 1;
11654               }
11655             else if (current_function_decl)
11656               {
11657                 /* FIXME need arm citation */
11658                 error ("cannot declare static function inside another function");
11659                 illegal_static = 1;
11660               }
11661
11662             if (illegal_static)
11663               {
11664                 staticp = 0;
11665                 RIDBIT_RESET (RID_STATIC, specbits);
11666               }
11667           }
11668       }
11669     else
11670       {
11671         /* It's a variable.  */
11672
11673         /* An uninitialized decl with `extern' is a reference.  */
11674         decl = grokvardecl (type, declarator, &specbits,
11675                             initialized,
11676                             (type_quals & TYPE_QUAL_CONST) != 0,
11677                             in_namespace);
11678         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11679                         inlinep, friendp, raises != NULL_TREE);
11680
11681         if (ctype)
11682           {
11683             DECL_CONTEXT (decl) = ctype;
11684             if (staticp == 1)
11685               {
11686                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11687                 staticp = 0;
11688                 RIDBIT_RESET (RID_STATIC, specbits);
11689               }
11690             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11691               {
11692                 cp_error ("static member `%D' declared `register'", decl);
11693                 RIDBIT_RESET (RID_REGISTER, specbits);
11694               }
11695             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11696               {
11697                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11698                             decl);
11699                 RIDBIT_RESET (RID_EXTERN, specbits);
11700               }
11701           }
11702       }
11703
11704     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11705
11706     /* Record `register' declaration for warnings on &
11707        and in case doing stupid register allocation.  */
11708
11709     if (RIDBIT_SETP (RID_REGISTER, specbits))
11710       DECL_REGISTER (decl) = 1;
11711
11712     if (RIDBIT_SETP (RID_EXTERN, specbits))
11713       DECL_THIS_EXTERN (decl) = 1;
11714
11715     if (RIDBIT_SETP (RID_STATIC, specbits))
11716       DECL_THIS_STATIC (decl) = 1;
11717
11718     /* Record constancy and volatility.  There's no need to do this
11719        when processing a template; we'll do this for the instantiated
11720        declaration based on the type of DECL.  */
11721     if (!processing_template_decl)
11722       c_apply_type_quals_to_decl (type_quals, decl);
11723
11724     return decl;
11725   }
11726 }
11727 \f
11728 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11729    An empty exprlist is a parmlist.  An exprlist which
11730    contains only identifiers at the global level
11731    is a parmlist.  Otherwise, it is an exprlist.  */
11732
11733 int
11734 parmlist_is_exprlist (exprs)
11735      tree exprs;
11736 {
11737   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11738     return 0;
11739
11740   if (toplevel_bindings_p ())
11741     {
11742       /* At the global level, if these are all identifiers,
11743          then it is a parmlist.  */
11744       while (exprs)
11745         {
11746           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11747             return 1;
11748           exprs = TREE_CHAIN (exprs);
11749         }
11750       return 0;
11751     }
11752   return 1;
11753 }
11754
11755 /* Subroutine of start_function.  Ensure that each of the parameter
11756    types (as listed in PARMS) is complete, as is required for a
11757    function definition.  */
11758
11759 static void
11760 require_complete_types_for_parms (parms)
11761      tree parms;
11762 {
11763   for (; parms; parms = TREE_CHAIN (parms))
11764     {
11765       tree type = TREE_TYPE (parms);
11766
11767       /* Try to complete the TYPE.  */
11768       type = complete_type (type);
11769
11770       if (type == error_mark_node)
11771         continue;
11772
11773       if (!COMPLETE_TYPE_P (type))
11774         {
11775           if (DECL_NAME (parms))
11776             error ("parameter `%s' has incomplete type",
11777                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11778           else
11779             error ("parameter has incomplete type");
11780           TREE_TYPE (parms) = error_mark_node;
11781         }
11782       else
11783         layout_decl (parms, 0);
11784     }
11785 }
11786
11787 /* Returns non-zero if T is a local variable.  */
11788
11789 int
11790 local_variable_p (t)
11791      tree t;
11792 {
11793   if ((TREE_CODE (t) == VAR_DECL
11794        /* A VAR_DECL with a context that is a _TYPE is a static data
11795           member.  */
11796        && !TYPE_P (CP_DECL_CONTEXT (t))
11797        /* Any other non-local variable must be at namespace scope.  */
11798        && !DECL_NAMESPACE_SCOPE_P (t))
11799       || (TREE_CODE (t) == PARM_DECL))
11800     return 1;
11801
11802   return 0;
11803 }
11804
11805 /* Returns non-zero if T is an automatic local variable or a label.
11806    (These are the declarations that need to be remapped when the code
11807    containing them is duplicated.)  */
11808
11809 int
11810 nonstatic_local_decl_p (t)
11811      tree t;
11812 {
11813   return ((local_variable_p (t) && !TREE_STATIC (t))
11814           || TREE_CODE (t) == LABEL_DECL
11815           || TREE_CODE (t) == RESULT_DECL);
11816 }
11817
11818 /* Like local_variable_p, but suitable for use as a tree-walking
11819    function.  */
11820
11821 static tree
11822 local_variable_p_walkfn (tp, walk_subtrees, data)
11823      tree *tp;
11824      int *walk_subtrees ATTRIBUTE_UNUSED;
11825      void *data ATTRIBUTE_UNUSED;
11826 {
11827   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11828           ? *tp : NULL_TREE);
11829 }
11830
11831 /* Check that ARG, which is a default-argument expression for a
11832    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11833    something goes wrong.  DECL may also be a _TYPE node, rather than a
11834    DECL, if there is no DECL available.  */
11835
11836 tree
11837 check_default_argument (decl, arg)
11838      tree decl;
11839      tree arg;
11840 {
11841   tree var;
11842   tree decl_type;
11843
11844   if (TREE_CODE (arg) == DEFAULT_ARG)
11845     /* We get a DEFAULT_ARG when looking at an in-class declaration
11846        with a default argument.  Ignore the argument for now; we'll
11847        deal with it after the class is complete.  */
11848     return arg;
11849
11850   if (processing_template_decl || uses_template_parms (arg))
11851     /* We don't do anything checking until instantiation-time.  Note
11852        that there may be uninstantiated arguments even for an
11853        instantiated function, since default arguments are not
11854        instantiated until they are needed.  */
11855     return arg;
11856
11857   if (TYPE_P (decl))
11858     {
11859       decl_type = decl;
11860       decl = NULL_TREE;
11861     }
11862   else
11863     decl_type = TREE_TYPE (decl);
11864
11865   if (arg == error_mark_node
11866       || decl == error_mark_node
11867       || TREE_TYPE (arg) == error_mark_node
11868       || decl_type == error_mark_node)
11869     /* Something already went wrong.  There's no need to check
11870        further.  */
11871     return error_mark_node;
11872
11873   /* [dcl.fct.default]
11874
11875      A default argument expression is implicitly converted to the
11876      parameter type.  */
11877   if (!TREE_TYPE (arg)
11878       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11879     {
11880       if (decl)
11881         cp_error ("default argument for `%#D' has type `%T'",
11882                   decl, TREE_TYPE (arg));
11883       else
11884         cp_error ("default argument for parameter of type `%T' has type `%T'",
11885                   decl_type, TREE_TYPE (arg));
11886
11887       return error_mark_node;
11888     }
11889
11890   /* [dcl.fct.default]
11891
11892      Local variables shall not be used in default argument
11893      expressions.
11894
11895      The keyword `this' shall not be used in a default argument of a
11896      member function.  */
11897   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11898   if (var)
11899     {
11900       cp_error ("default argument `%E' uses local variable `%D'",
11901                 arg, var);
11902       return error_mark_node;
11903     }
11904
11905   /* All is well.  */
11906   return arg;
11907 }
11908
11909 /* Decode the list of parameter types for a function type.
11910    Given the list of things declared inside the parens,
11911    return a list of types.
11912
11913    The list we receive can have three kinds of elements:
11914    an IDENTIFIER_NODE for names given without types,
11915    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11916    or void_type_node, to mark the end of an argument list
11917    when additional arguments are not permitted (... was not used).
11918
11919    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11920    a mere declaration.  A nonempty identifier-list gets an error message
11921    when FUNCDEF_FLAG is zero.
11922    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11923    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11924
11925    If all elements of the input list contain types,
11926    we return a list of the types.
11927    If all elements contain no type (except perhaps a void_type_node
11928    at the end), we return a null list.
11929    If some have types and some do not, it is an error, and we
11930    return a null list.
11931
11932    Also set last_function_parms to either
11933    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11934    A list of names is converted to a chain of PARM_DECLs
11935    by store_parm_decls so that ultimately it is always a chain of decls.
11936
11937    Note that in C++, parameters can take default values.  These default
11938    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11939    an error to specify default values which are followed by parameters
11940    that have no default values, or an ELLIPSES.  For simplicities sake,
11941    only parameters which are specified with their types can take on
11942    default values.  */
11943
11944 static tree
11945 grokparms (first_parm, funcdef_flag)
11946      tree first_parm;
11947      int funcdef_flag;
11948 {
11949   tree result = NULL_TREE;
11950   tree decls = NULL_TREE;
11951
11952   if (first_parm != NULL_TREE
11953       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11954     {
11955       if (! funcdef_flag)
11956         pedwarn ("parameter names (without types) in function declaration");
11957       last_function_parms = first_parm;
11958       return NULL_TREE;
11959     }
11960   else if (first_parm != NULL_TREE
11961            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11962            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11963     my_friendly_abort (145);
11964   else
11965     {
11966       /* Types were specified.  This is a list of declarators
11967          each represented as a TREE_LIST node.  */
11968       register tree parm, chain;
11969       int any_init = 0, any_error = 0;
11970
11971       if (first_parm != NULL_TREE)
11972         {
11973           tree last_result = NULL_TREE;
11974           tree last_decl = NULL_TREE;
11975
11976           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11977             {
11978               tree type = NULL_TREE, list_node = parm;
11979               register tree decl = TREE_VALUE (parm);
11980               tree init = TREE_PURPOSE (parm);
11981
11982               chain = TREE_CHAIN (parm);
11983               /* @@ weak defense against parse errors.  */
11984               if (TREE_CODE (decl) != VOID_TYPE
11985                   && TREE_CODE (decl) != TREE_LIST)
11986                 {
11987                   /* Give various messages as the need arises.  */
11988                   if (TREE_CODE (decl) == STRING_CST)
11989                     cp_error ("invalid string constant `%E'", decl);
11990                   else if (TREE_CODE (decl) == INTEGER_CST)
11991                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11992                   continue;
11993                 }
11994
11995               if (TREE_CODE (decl) != VOID_TYPE)
11996                 {
11997                   decl = grokdeclarator (TREE_VALUE (decl),
11998                                          TREE_PURPOSE (decl),
11999                                          PARM, init != NULL_TREE,
12000                                          NULL_TREE);
12001                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12002                     continue;
12003
12004                   /* Top-level qualifiers on the parameters are
12005                      ignored for function types.  */
12006                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12007
12008                   if (TREE_CODE (type) == VOID_TYPE)
12009                     decl = void_type_node;
12010                   else if (TREE_CODE (type) == METHOD_TYPE)
12011                     {
12012                       if (DECL_NAME (decl))
12013                         /* Cannot use the decl here because
12014                            we don't have DECL_CONTEXT set up yet.  */
12015                         cp_error ("parameter `%D' invalidly declared method type",
12016                                   DECL_NAME (decl));
12017                       else
12018                         error ("parameter invalidly declared method type");
12019                       type = build_pointer_type (type);
12020                       TREE_TYPE (decl) = type;
12021                     }
12022                   else if (TREE_CODE (type) == OFFSET_TYPE)
12023                     {
12024                       if (DECL_NAME (decl))
12025                         cp_error ("parameter `%D' invalidly declared offset type",
12026                                   DECL_NAME (decl));
12027                       else
12028                         error ("parameter invalidly declared offset type");
12029                       type = build_pointer_type (type);
12030                       TREE_TYPE (decl) = type;
12031                     }
12032                   else if (abstract_virtuals_error (decl, type))
12033                     any_error = 1;  /* Seems like a good idea. */
12034                   else if (POINTER_TYPE_P (type))
12035                     {
12036                       tree t = type;
12037                       while (POINTER_TYPE_P (t)
12038                              || (TREE_CODE (t) == ARRAY_TYPE
12039                                  && TYPE_DOMAIN (t) != NULL_TREE))
12040                         t = TREE_TYPE (t);
12041                       if (TREE_CODE (t) == ARRAY_TYPE)
12042                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12043                                   type,
12044                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12045                     }
12046                 }
12047
12048               if (TREE_CODE (decl) == VOID_TYPE)
12049                 {
12050                   if (result == NULL_TREE)
12051                     {
12052                       result = void_list_node;
12053                       last_result = result;
12054                     }
12055                   else
12056                     {
12057                       TREE_CHAIN (last_result) = void_list_node;
12058                       last_result = void_list_node;
12059                     }
12060                   if (chain
12061                       && (chain != void_list_node || TREE_CHAIN (chain)))
12062                     error ("`void' in parameter list must be entire list");
12063                   break;
12064                 }
12065
12066               /* Since there is a prototype, args are passed in their own types.  */
12067               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12068               if (PROMOTE_PROTOTYPES
12069                   && (TREE_CODE (type) == INTEGER_TYPE
12070                       || TREE_CODE (type) == ENUMERAL_TYPE)
12071                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12072                 DECL_ARG_TYPE (decl) = integer_type_node;
12073               if (!any_error && init)
12074                 {
12075                   any_init++;
12076                   init = check_default_argument (decl, init);
12077                 }
12078               else
12079                 init = NULL_TREE;
12080
12081               if (decls == NULL_TREE)
12082                 {
12083                   decls = decl;
12084                   last_decl = decls;
12085                 }
12086               else
12087                 {
12088                   TREE_CHAIN (last_decl) = decl;
12089                   last_decl = decl;
12090                 }
12091               list_node = tree_cons (init, type, NULL_TREE);
12092               if (result == NULL_TREE)
12093                 {
12094                   result = list_node;
12095                   last_result = result;
12096                 }
12097               else
12098                 {
12099                   TREE_CHAIN (last_result) = list_node;
12100                   last_result = list_node;
12101                 }
12102             }
12103           if (last_result)
12104             TREE_CHAIN (last_result) = NULL_TREE;
12105           /* If there are no parameters, and the function does not end
12106              with `...', then last_decl will be NULL_TREE.  */
12107           if (last_decl != NULL_TREE)
12108             TREE_CHAIN (last_decl) = NULL_TREE;
12109         }
12110     }
12111
12112   last_function_parms = decls;
12113
12114   return result;
12115 }
12116
12117 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12118    FUNCTION_TYPE with the newly parsed version of its default argument, which
12119    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12120
12121 void
12122 replace_defarg (arg, init)
12123      tree arg, init;
12124 {
12125   if (! processing_template_decl
12126       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12127     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12128                 TREE_TYPE (init), TREE_VALUE (arg));
12129   TREE_PURPOSE (arg) = init;
12130 }
12131 \f
12132 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12133    D's arguments allow it to be a copy constructor, or copy assignment
12134    operator.  */
12135
12136 int
12137 copy_args_p (d)
12138      tree d;
12139 {
12140   tree t;
12141
12142   if (!DECL_FUNCTION_MEMBER_P (d))
12143     return 0;
12144
12145   t = FUNCTION_ARG_CHAIN (d);
12146   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12147     t = TREE_CHAIN (t);
12148   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12149       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12150           == DECL_CONTEXT (d))
12151       && (TREE_CHAIN (t) == NULL_TREE
12152           || TREE_CHAIN (t) == void_list_node
12153           || TREE_PURPOSE (TREE_CHAIN (t))))
12154     return 1;
12155   return 0;
12156 }
12157
12158 /* These memoizing functions keep track of special properties which
12159    a class may have.  `grok_ctor_properties' notices whether a class
12160    has a constructor of the form X(X&), and also complains
12161    if the class has a constructor of the form X(X).
12162    `grok_op_properties' takes notice of the various forms of
12163    operator= which are defined, as well as what sorts of type conversion
12164    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12165
12166 int
12167 grok_ctor_properties (ctype, decl)
12168      tree ctype, decl;
12169 {
12170   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12171   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12172
12173   /* When a type has virtual baseclasses, a magical first int argument is
12174      added to any ctor so we can tell if the class has been initialized
12175      yet.  This could screw things up in this function, so we deliberately
12176      ignore the leading int if we're in that situation.  */
12177   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12178     {
12179       my_friendly_assert (parmtypes
12180                           && TREE_VALUE (parmtypes) == integer_type_node,
12181                           980529);
12182       parmtypes = TREE_CHAIN (parmtypes);
12183       parmtype = TREE_VALUE (parmtypes);
12184     }
12185
12186   /* [class.copy]
12187
12188      A non-template constructor for class X is a copy constructor if
12189      its first parameter is of type X&, const X&, volatile X& or const
12190      volatile X&, and either there are no other parameters or else all
12191      other parameters have default arguments.  */
12192   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12193       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12194       && (TREE_CHAIN (parmtypes) == NULL_TREE
12195           || TREE_CHAIN (parmtypes) == void_list_node
12196           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12197       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12198            && is_member_template (DECL_TI_TEMPLATE (decl))))
12199     {
12200       TYPE_HAS_INIT_REF (ctype) = 1;
12201       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12202         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12203     }
12204   /* [class.copy]
12205
12206      A declaration of a constructor for a class X is ill-formed if its
12207      first parameter is of type (optionally cv-qualified) X and either
12208      there are no other parameters or else all other parameters have
12209      default arguments.
12210
12211      We *don't* complain about member template instantiations that
12212      have this form, though; they can occur as we try to decide what
12213      constructor to use during overload resolution.  Since overload
12214      resolution will never prefer such a constructor to the
12215      non-template copy constructor (which is either explicitly or
12216      implicitly defined), there's no need to worry about their
12217      existence.  Theoretically, they should never even be
12218      instantiated, but that's hard to forestall.  */
12219   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12220            && (TREE_CHAIN (parmtypes) == NULL_TREE
12221                || TREE_CHAIN (parmtypes) == void_list_node
12222                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12223            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12224                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12225     {
12226       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12227                 ctype, ctype);
12228       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12229       return 0;
12230     }
12231   else if (TREE_CODE (parmtype) == VOID_TYPE
12232            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12233     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12234
12235   return 1;
12236 }
12237
12238 /* An operator with this code is unary, but can also be binary.  */
12239
12240 static int
12241 ambi_op_p (code)
12242      enum tree_code code;
12243 {
12244   return (code == INDIRECT_REF
12245           || code == ADDR_EXPR
12246           || code == CONVERT_EXPR
12247           || code == NEGATE_EXPR
12248           || code == PREINCREMENT_EXPR
12249           || code == PREDECREMENT_EXPR);
12250 }
12251
12252 /* An operator with this name can only be unary.  */
12253
12254 static int
12255 unary_op_p (code)
12256      enum tree_code code;
12257 {
12258   return (code == TRUTH_NOT_EXPR
12259           || code == BIT_NOT_EXPR
12260           || code == COMPONENT_REF
12261           || code == TYPE_EXPR);
12262 }
12263
12264 /* Do a little sanity-checking on how they declared their operator.  */
12265
12266 void
12267 grok_op_properties (decl, virtualp, friendp)
12268      tree decl;
12269      int virtualp, friendp;
12270 {
12271   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12272   tree argtype;
12273   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12274   tree name = DECL_NAME (decl);
12275   enum tree_code operator_code;
12276   int arity;
12277
12278   /* Count the number of arguments.  */
12279   for (argtype = argtypes, arity = 0;
12280        argtype && argtype != void_list_node;
12281        argtype = TREE_CHAIN (argtype))
12282     ++arity;
12283
12284   if (current_class_type == NULL_TREE)
12285     friendp = 1;
12286
12287   if (DECL_CONV_FN_P (decl))
12288     operator_code = TYPE_EXPR;
12289   else
12290     do
12291       {
12292 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12293         if (ansi_opname (CODE) == name)                                     \
12294           {                                                                 \
12295             operator_code = CODE;                                           \
12296             break;                                                          \
12297           }                                                                 \
12298         else if (ansi_assopname (CODE) == name)                             \
12299           {                                                                 \
12300             operator_code = CODE;                                           \
12301             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12302             break;                                                          \
12303           }
12304
12305 #include "operators.def"
12306 #undef DEF_OPERATOR
12307
12308         my_friendly_abort (20000527);
12309       }
12310     while (0);
12311   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12312   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12313
12314   if (! friendp)
12315     {
12316       switch (operator_code)
12317         {
12318         case CALL_EXPR:
12319           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12320           break;
12321
12322         case ARRAY_REF:
12323           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12324           break;
12325
12326         case COMPONENT_REF:
12327         case MEMBER_REF:
12328           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12329           break;
12330
12331         case NEW_EXPR:
12332           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12333           break;
12334
12335         case DELETE_EXPR:
12336           TYPE_GETS_DELETE (current_class_type) |= 1;
12337           break;
12338
12339         case VEC_NEW_EXPR:
12340           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12341           break;
12342
12343         case VEC_DELETE_EXPR:
12344           TYPE_GETS_DELETE (current_class_type) |= 2;
12345           break;
12346
12347         default:
12348           break;
12349         }
12350     }
12351
12352   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12353     {
12354       /* When the compiler encounters the definition of A::operator new, it
12355          doesn't look at the class declaration to find out if it's static.  */
12356       if (methodp)
12357         revert_static_member_fn (decl);
12358
12359       /* Take care of function decl if we had syntax errors.  */
12360       if (argtypes == NULL_TREE)
12361         TREE_TYPE (decl)
12362           = build_function_type (ptr_type_node,
12363                                  hash_tree_chain (integer_type_node,
12364                                                   void_list_node));
12365       else
12366         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12367     }
12368   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12369     {
12370       if (methodp)
12371         revert_static_member_fn (decl);
12372
12373       if (argtypes == NULL_TREE)
12374         TREE_TYPE (decl)
12375           = build_function_type (void_type_node,
12376                                  hash_tree_chain (ptr_type_node,
12377                                                   void_list_node));
12378       else
12379         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12380     }
12381   else
12382     {
12383       /* An operator function must either be a non-static member function
12384          or have at least one parameter of a class, a reference to a class,
12385          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12386       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12387         {
12388           if (operator_code == TYPE_EXPR
12389               || operator_code == CALL_EXPR
12390               || operator_code == COMPONENT_REF
12391               || operator_code == ARRAY_REF
12392               || operator_code == NOP_EXPR)
12393             cp_error ("`%D' must be a nonstatic member function", decl);
12394           else
12395             {
12396               tree p = argtypes;
12397
12398               if (DECL_STATIC_FUNCTION_P (decl))
12399                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12400
12401               if (p)
12402                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12403                   {
12404                     tree arg = TREE_VALUE (p);
12405                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12406                       arg = TREE_TYPE (arg);
12407
12408                     /* This lets bad template code slip through.  */
12409                     if (IS_AGGR_TYPE (arg)
12410                         || TREE_CODE (arg) == ENUMERAL_TYPE
12411                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12412                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12413                       goto foundaggr;
12414                   }
12415               cp_error
12416                 ("`%D' must have an argument of class or enumerated type",
12417                  decl);
12418             foundaggr:
12419               ;
12420             }
12421         }
12422
12423       if (operator_code == CALL_EXPR)
12424         return;                 /* No restrictions on args. */
12425
12426       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12427         {
12428           tree t = TREE_TYPE (name);
12429           if (! friendp)
12430             {
12431               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12432               const char *what = 0;
12433
12434               if (ref)
12435                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12436
12437               if (TREE_CODE (t) == VOID_TYPE)
12438                 what = "void";
12439               else if (t == current_class_type)
12440                 what = "the same type";
12441               /* Don't force t to be complete here.  */
12442               else if (IS_AGGR_TYPE (t)
12443                        && COMPLETE_TYPE_P (t)
12444                        && DERIVED_FROM_P (t, current_class_type))
12445                 what = "a base class";
12446
12447               if (what)
12448                 warning ("conversion to %s%s will never use a type conversion operator",
12449                          ref ? "a reference to " : "", what);
12450             }
12451         }
12452
12453       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12454           && operator_code == NOP_EXPR)
12455         {
12456           tree parmtype;
12457
12458           if (arity != 2 && methodp)
12459             {
12460               cp_error ("`%D' must take exactly one argument", decl);
12461               return;
12462             }
12463           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12464
12465           /* [class.copy]
12466
12467              A user-declared copy assignment operator X::operator= is
12468              a non-static non-template member function of class X with
12469              exactly one parameter of type X, X&, const X&, volatile
12470              X& or const volatile X&.  */
12471           if (copy_assignment_arg_p (parmtype, virtualp)
12472               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12473                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12474               && ! friendp)
12475             {
12476               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12477               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12478                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12479                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12480             }
12481         }
12482       else if (operator_code == COND_EXPR)
12483         {
12484           /* 13.4.0.3 */
12485           cp_error ("ISO C++ prohibits overloading operator ?:");
12486         }
12487       else if (ambi_op_p (operator_code))
12488         {
12489           if (arity == 1)
12490             /* We pick the one-argument operator codes by default, so
12491                we don't have to change anything.  */
12492             ;
12493           else if (arity == 2)
12494             {
12495               /* If we thought this was a unary operator, we now know
12496                  it to be a binary operator.  */
12497               switch (operator_code)
12498                 {
12499                 case INDIRECT_REF:
12500                   operator_code = MULT_EXPR;
12501                   break;
12502
12503                 case ADDR_EXPR:
12504                   operator_code = BIT_AND_EXPR;
12505                   break;
12506
12507                 case CONVERT_EXPR:
12508                   operator_code = PLUS_EXPR;
12509                   break;
12510
12511                 case NEGATE_EXPR:
12512                   operator_code = MINUS_EXPR;
12513                   break;
12514
12515                 case PREINCREMENT_EXPR:
12516                   operator_code = POSTINCREMENT_EXPR;
12517                   break;
12518
12519                 case PREDECREMENT_EXPR:
12520                   operator_code = POSTDECREMENT_EXPR;
12521                   break;
12522
12523                 default:
12524                   my_friendly_abort (20000527);
12525                 }
12526
12527               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12528
12529               if ((operator_code == POSTINCREMENT_EXPR
12530                    || operator_code == POSTDECREMENT_EXPR)
12531                   && ! processing_template_decl
12532                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12533                 {
12534                   if (methodp)
12535                     cp_error ("postfix `%D' must take `int' as its argument",
12536                               decl);
12537                   else
12538                     cp_error
12539                       ("postfix `%D' must take `int' as its second argument",
12540                        decl);
12541                 }
12542             }
12543           else
12544             {
12545               if (methodp)
12546                 cp_error ("`%D' must take either zero or one argument", decl);
12547               else
12548                 cp_error ("`%D' must take either one or two arguments", decl);
12549             }
12550
12551           /* More Effective C++ rule 6.  */
12552           if (warn_ecpp
12553               && (operator_code == POSTINCREMENT_EXPR
12554                   || operator_code == POSTDECREMENT_EXPR
12555                   || operator_code == PREINCREMENT_EXPR
12556                   || operator_code == PREDECREMENT_EXPR))
12557             {
12558               tree arg = TREE_VALUE (argtypes);
12559               tree ret = TREE_TYPE (TREE_TYPE (decl));
12560               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12561                 arg = TREE_TYPE (arg);
12562               arg = TYPE_MAIN_VARIANT (arg);
12563               if (operator_code == PREINCREMENT_EXPR
12564                   || operator_code == PREDECREMENT_EXPR)
12565                 {
12566                   if (TREE_CODE (ret) != REFERENCE_TYPE
12567                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12568                                        arg))
12569                     cp_warning ("prefix `%D' should return `%T'", decl,
12570                                 build_reference_type (arg));
12571                 }
12572               else
12573                 {
12574                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12575                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12576                 }
12577             }
12578         }
12579       else if (unary_op_p (operator_code))
12580         {
12581           if (arity != 1)
12582             {
12583               if (methodp)
12584                 cp_error ("`%D' must take `void'", decl);
12585               else
12586                 cp_error ("`%D' must take exactly one argument", decl);
12587             }
12588         }
12589       else /* if (binary_op_p (operator_code)) */
12590         {
12591           if (arity != 2)
12592             {
12593               if (methodp)
12594                 cp_error ("`%D' must take exactly one argument", decl);
12595               else
12596                 cp_error ("`%D' must take exactly two arguments", decl);
12597             }
12598
12599           /* More Effective C++ rule 7.  */
12600           if (warn_ecpp
12601               && (operator_code == TRUTH_ANDIF_EXPR
12602                   || operator_code == TRUTH_ORIF_EXPR
12603                   || operator_code == COMPOUND_EXPR))
12604             cp_warning ("user-defined `%D' always evaluates both arguments",
12605                         decl);
12606         }
12607
12608       /* Effective C++ rule 23.  */
12609       if (warn_ecpp
12610           && arity == 2
12611           && (operator_code == PLUS_EXPR
12612               || operator_code == MINUS_EXPR
12613               || operator_code == TRUNC_DIV_EXPR
12614               || operator_code == MULT_EXPR)
12615           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12616         cp_warning ("`%D' should return by value", decl);
12617
12618       /* 13.4.0.8 */
12619       for (; argtypes && argtypes != void_list_node;
12620           argtypes = TREE_CHAIN (argtypes))
12621         if (TREE_PURPOSE (argtypes))
12622           {
12623             TREE_PURPOSE (argtypes) = NULL_TREE;
12624             if (operator_code == POSTINCREMENT_EXPR
12625                 || operator_code == POSTDECREMENT_EXPR)
12626               {
12627                 if (pedantic)
12628                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12629               }
12630             else
12631               cp_error ("`%D' cannot have default arguments", decl);
12632           }
12633
12634     }
12635 }
12636 \f
12637 static const char *
12638 tag_name (code)
12639      enum tag_types code;
12640 {
12641   switch (code)
12642     {
12643     case record_type:
12644       return "struct";
12645     case class_type:
12646       return "class";
12647     case union_type:
12648       return "union ";
12649     case enum_type:
12650       return "enum";
12651     default:
12652       my_friendly_abort (981122);
12653     }
12654 }
12655
12656 /* Get the struct, enum or union (CODE says which) with tag NAME.
12657    Define the tag as a forward-reference if it is not defined.
12658
12659    C++: If a class derivation is given, process it here, and report
12660    an error if multiple derivation declarations are not identical.
12661
12662    If this is a definition, come in through xref_tag and only look in
12663    the current frame for the name (since C++ allows new names in any
12664    scope.)  */
12665
12666 tree
12667 xref_tag (code_type_node, name, globalize)
12668      tree code_type_node;
12669      tree name;
12670      int globalize;
12671 {
12672   enum tag_types tag_code;
12673   enum tree_code code;
12674   register tree ref, t;
12675   struct binding_level *b = current_binding_level;
12676   int got_type = 0;
12677   tree attributes = NULL_TREE;
12678   tree context = NULL_TREE;
12679
12680   /* If we are called from the parser, code_type_node will sometimes be a
12681      TREE_LIST.  This indicates that the user wrote
12682      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12683      use them later.  */
12684   if (TREE_CODE (code_type_node) == TREE_LIST)
12685     {
12686       attributes = TREE_PURPOSE (code_type_node);
12687       code_type_node = TREE_VALUE (code_type_node);
12688     }
12689
12690   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12691   switch (tag_code)
12692     {
12693     case record_type:
12694     case class_type:
12695       code = RECORD_TYPE;
12696       break;
12697     case union_type:
12698       code = UNION_TYPE;
12699       break;
12700     case enum_type:
12701       code = ENUMERAL_TYPE;
12702       break;
12703     default:
12704       my_friendly_abort (18);
12705     }
12706
12707   /* If a cross reference is requested, look up the type
12708      already defined for this tag and return it.  */
12709   if (TYPE_P (name))
12710     {
12711       t = name;
12712       name = TYPE_IDENTIFIER (t);
12713       got_type = 1;
12714     }
12715   else
12716     t = IDENTIFIER_TYPE_VALUE (name);
12717
12718   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12719       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12720     t = NULL_TREE;
12721
12722   if (! globalize)
12723     {
12724       /* If we know we are defining this tag, only look it up in
12725          this scope and don't try to find it as a type.  */
12726       ref = lookup_tag (code, name, b, 1);
12727     }
12728   else
12729     {
12730       if (t)
12731         {
12732           /* [dcl.type.elab] If the identifier resolves to a
12733              typedef-name or a template type-parameter, the
12734              elaborated-type-specifier is ill-formed.  */
12735           if (t != TYPE_MAIN_VARIANT (t)
12736               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12737             cp_pedwarn ("using typedef-name `%D' after `%s'",
12738                         TYPE_NAME (t), tag_name (tag_code));
12739           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12740             cp_error ("using template type parameter `%T' after `%s'",
12741                       t, tag_name (tag_code));
12742
12743           ref = t;
12744         }
12745       else
12746         ref = lookup_tag (code, name, b, 0);
12747
12748       if (! ref)
12749         {
12750           /* Try finding it as a type declaration.  If that wins,
12751              use it.  */
12752           ref = lookup_name (name, 1);
12753
12754           if (ref != NULL_TREE
12755               && processing_template_decl
12756               && DECL_CLASS_TEMPLATE_P (ref)
12757               && template_class_depth (current_class_type) == 0)
12758             /* Since GLOBALIZE is true, we're declaring a global
12759                template, so we want this type.  */
12760             ref = DECL_TEMPLATE_RESULT (ref);
12761
12762           if (ref && TREE_CODE (ref) == TYPE_DECL
12763               && TREE_CODE (TREE_TYPE (ref)) == code)
12764             ref = TREE_TYPE (ref);
12765           else
12766             ref = NULL_TREE;
12767         }
12768
12769       if (ref && current_class_type
12770           && template_class_depth (current_class_type)
12771           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12772         {
12773           /* Since GLOBALIZE is non-zero, we are not looking at a
12774              definition of this tag.  Since, in addition, we are currently
12775              processing a (member) template declaration of a template
12776              class, we must be very careful; consider:
12777
12778                template <class X>
12779                struct S1
12780
12781                template <class U>
12782                struct S2
12783                { template <class V>
12784                friend struct S1; };
12785
12786              Here, the S2::S1 declaration should not be confused with the
12787              outer declaration.  In particular, the inner version should
12788              have a template parameter of level 2, not level 1.  This
12789              would be particularly important if the member declaration
12790              were instead:
12791
12792                template <class V = U> friend struct S1;
12793
12794              say, when we should tsubst into `U' when instantiating
12795              S2.  On the other hand, when presented with:
12796
12797                  template <class T>
12798                  struct S1 {
12799                    template <class U>
12800                    struct S2 {};
12801                    template <class U>
12802                    friend struct S2;
12803                  };
12804
12805               we must find the inner binding eventually.  We
12806               accomplish this by making sure that the new type we
12807               create to represent this declaration has the right
12808               TYPE_CONTEXT.  */
12809           context = TYPE_CONTEXT (ref);
12810           ref = NULL_TREE;
12811         }
12812     }
12813
12814   if (! ref)
12815     {
12816       /* If no such tag is yet defined, create a forward-reference node
12817          and record it as the "definition".
12818          When a real declaration of this type is found,
12819          the forward-reference will be altered into a real type.  */
12820       if (code == ENUMERAL_TYPE)
12821         {
12822           cp_error ("use of enum `%#D' without previous declaration", name);
12823
12824           ref = make_node (ENUMERAL_TYPE);
12825
12826           /* Give the type a default layout like unsigned int
12827              to avoid crashing if it does not get defined.  */
12828           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12829           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12830           TYPE_USER_ALIGN (ref) = 0;
12831           TREE_UNSIGNED (ref) = 1;
12832           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12833           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12834           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12835
12836           /* Enable us to recognize when a type is created in class context.
12837              To do nested classes correctly, this should probably be cleared
12838              out when we leave this classes scope.  Currently this in only
12839              done in `start_enum'.  */
12840
12841           pushtag (name, ref, globalize);
12842         }
12843       else
12844         {
12845           struct binding_level *old_b = class_binding_level;
12846
12847           ref = make_aggr_type (code);
12848           TYPE_CONTEXT (ref) = context;
12849
12850 #ifdef NONNESTED_CLASSES
12851           /* Class types don't nest the way enums do.  */
12852           class_binding_level = (struct binding_level *)0;
12853 #endif
12854           pushtag (name, ref, globalize);
12855           class_binding_level = old_b;
12856         }
12857     }
12858   else
12859     {
12860       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12861         redeclare_class_template (ref, current_template_parms);
12862     }
12863
12864   /* Until the type is defined, tentatively accept whatever
12865      structure tag the user hands us.  */
12866   if (!COMPLETE_TYPE_P (ref)
12867       && ref != current_class_type
12868       /* Have to check this, in case we have contradictory tag info.  */
12869       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12870     {
12871       if (tag_code == class_type)
12872         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12873       else if (tag_code == record_type)
12874         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12875     }
12876
12877   TREE_TYPE (ref) = attributes;
12878
12879   return ref;
12880 }
12881
12882 tree
12883 xref_tag_from_type (old, id, globalize)
12884      tree old, id;
12885      int globalize;
12886 {
12887   tree code_type_node;
12888
12889   if (TREE_CODE (old) == RECORD_TYPE)
12890     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12891                       ? class_type_node : record_type_node);
12892   else
12893     code_type_node = union_type_node;
12894
12895   if (id == NULL_TREE)
12896     id = TYPE_IDENTIFIER (old);
12897
12898   return xref_tag (code_type_node, id, globalize);
12899 }
12900
12901 /* REF is a type (named NAME), for which we have just seen some
12902    baseclasses.  BINFO is a list of those baseclasses; the
12903    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12904    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12905    struct, or union.  */
12906
12907 void
12908 xref_basetypes (code_type_node, name, ref, binfo)
12909      tree code_type_node;
12910      tree name, ref;
12911      tree binfo;
12912 {
12913   /* In the declaration `A : X, Y, ... Z' we mark all the types
12914      (A, X, Y, ..., Z) so we can check for duplicates.  */
12915   tree binfos;
12916   tree base;
12917
12918   int i, len;
12919   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12920
12921   if (tag_code == union_type)
12922     {
12923       cp_error ("derived union `%T' invalid", ref);
12924       return;
12925     }
12926
12927   len = list_length (binfo);
12928
12929   /* First, make sure that any templates in base-classes are
12930      instantiated.  This ensures that if we call ourselves recursively
12931      we do not get confused about which classes are marked and which
12932      are not.  */
12933   for (base = binfo; base; base = TREE_CHAIN (base))
12934     complete_type (TREE_VALUE (base));
12935
12936   SET_CLASSTYPE_MARKED (ref);
12937   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12938
12939   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12940     {
12941       /* The base of a derived struct is public by default.  */
12942       int via_public
12943         = (TREE_PURPOSE (binfo) == access_public_node
12944            || TREE_PURPOSE (binfo) == access_public_virtual_node
12945            || (tag_code != class_type
12946                && (TREE_PURPOSE (binfo) == access_default_node
12947                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12948       int via_protected
12949         = (TREE_PURPOSE (binfo) == access_protected_node
12950            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12951       int via_virtual
12952         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12953            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12954            || TREE_PURPOSE (binfo) == access_public_virtual_node
12955            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12956       tree basetype = TREE_VALUE (binfo);
12957       tree base_binfo;
12958
12959       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12960         basetype = TREE_TYPE (basetype);
12961       if (!basetype
12962           || (TREE_CODE (basetype) != RECORD_TYPE
12963               && TREE_CODE (basetype) != TYPENAME_TYPE
12964               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12965               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12966         {
12967           cp_error ("base type `%T' fails to be a struct or class type",
12968                     TREE_VALUE (binfo));
12969           continue;
12970         }
12971
12972       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12973
12974       /* This code replaces similar code in layout_basetypes.
12975          We put the complete_type first for implicit `typename'.  */
12976       if (!COMPLETE_TYPE_P (basetype)
12977           && ! (current_template_parms && uses_template_parms (basetype)))
12978         {
12979           cp_error ("base class `%T' has incomplete type", basetype);
12980           continue;
12981         }
12982       else
12983         {
12984           if (CLASSTYPE_MARKED (basetype))
12985             {
12986               if (basetype == ref)
12987                 cp_error ("recursive type `%T' undefined", basetype);
12988               else
12989                 cp_error ("duplicate base type `%T' invalid", basetype);
12990               continue;
12991             }
12992
12993           if (TYPE_FOR_JAVA (basetype)
12994               && (current_lang_stack
12995                   == &VARRAY_TREE (current_lang_base, 0)))
12996             TYPE_FOR_JAVA (ref) = 1;
12997
12998           /* Note that the BINFO records which describe individual
12999              inheritances are *not* shared in the lattice!  They
13000              cannot be shared because a given baseclass may be
13001              inherited with different `accessibility' by different
13002              derived classes.  (Each BINFO record describing an
13003              individual inheritance contains flags which say what
13004              the `accessibility' of that particular inheritance is.)  */
13005
13006           base_binfo
13007             = make_binfo (size_zero_node, basetype,
13008                           CLASS_TYPE_P (basetype)
13009                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13010                           CLASS_TYPE_P (basetype)
13011                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13012
13013           TREE_VEC_ELT (binfos, i) = base_binfo;
13014           TREE_VIA_PUBLIC (base_binfo) = via_public;
13015           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13016           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13017           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13018
13019           /* We need to unshare the binfos now so that lookups during class
13020              definition work.  */
13021           unshare_base_binfos (base_binfo);
13022
13023           SET_CLASSTYPE_MARKED (basetype);
13024
13025           /* We are free to modify these bits because they are meaningless
13026              at top level, and BASETYPE is a top-level type.  */
13027           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13028             {
13029               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13030               /* Converting to a virtual base class requires looking
13031                  up the offset of the virtual base.  */
13032               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13033             }
13034
13035           if (CLASS_TYPE_P (basetype))
13036             {
13037               TYPE_HAS_NEW_OPERATOR (ref)
13038                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13039               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13040                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13041               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13042               /* If the base-class uses multiple inheritance, so do we.  */
13043               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13044                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13045               /* Likewise, if converting to a base of the base may require
13046                  code, then we may need to generate code to convert to a
13047                  base as well.  */
13048               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13049                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13050             }
13051
13052           i += 1;
13053         }
13054     }
13055   if (i)
13056     TREE_VEC_LENGTH (binfos) = i;
13057   else
13058     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13059
13060   if (i > 1)
13061     {
13062       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13063       /* If there is more than one non-empty they cannot be at the same
13064          address.  */
13065       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13066     }
13067
13068   /* Unmark all the types.  */
13069   while (--i >= 0)
13070     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13071   CLEAR_CLASSTYPE_MARKED (ref);
13072
13073   /* Now that we know all the base-classes, set up the list of virtual
13074      bases.  */
13075   get_vbase_types (ref);
13076 }
13077
13078 \f
13079 /* Begin compiling the definition of an enumeration type.
13080    NAME is its name (or null if anonymous).
13081    Returns the type object, as yet incomplete.
13082    Also records info about it so that build_enumerator
13083    may be used to declare the individual values as they are read.  */
13084
13085 tree
13086 start_enum (name)
13087      tree name;
13088 {
13089   register tree enumtype = NULL_TREE;
13090   struct binding_level *b = current_binding_level;
13091
13092   /* If this is the real definition for a previous forward reference,
13093      fill in the contents in the same object that used to be the
13094      forward reference.  */
13095
13096   if (name != NULL_TREE)
13097     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13098
13099   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13100     {
13101       cp_error ("multiple definition of `%#T'", enumtype);
13102       cp_error_at ("previous definition here", enumtype);
13103       /* Clear out TYPE_VALUES, and start again.  */
13104       TYPE_VALUES (enumtype) = NULL_TREE;
13105     }
13106   else
13107     {
13108       enumtype = make_node (ENUMERAL_TYPE);
13109       pushtag (name, enumtype, 0);
13110     }
13111
13112   if (current_class_type)
13113     TREE_ADDRESSABLE (b->tags) = 1;
13114
13115   GNU_xref_decl (current_function_decl, enumtype);
13116   return enumtype;
13117 }
13118
13119 /* After processing and defining all the values of an enumeration type,
13120    install their decls in the enumeration type and finish it off.
13121    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13122    Returns ENUMTYPE.  */
13123
13124 tree
13125 finish_enum (enumtype)
13126      tree enumtype;
13127 {
13128   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13129   /* Calculate the maximum value of any enumerator in this type.  */
13130
13131   tree values = TYPE_VALUES (enumtype);
13132   if (values)
13133     {
13134       tree pair;
13135
13136       for (pair = values; pair; pair = TREE_CHAIN (pair))
13137         {
13138           tree decl;
13139           tree value;
13140
13141           /* The TREE_VALUE is a CONST_DECL for this enumeration
13142              constant.  */
13143           decl = TREE_VALUE (pair);
13144
13145           /* [dcl.enum]
13146
13147              Following the closing brace of an enum-specifier, each
13148              enumerator has the type of its enumeration.  Prior to the
13149              closing brace, the type of each enumerator is the type of
13150              its initializing value.  */
13151           TREE_TYPE (decl) = enumtype;
13152
13153           /* The DECL_INITIAL will be NULL if we are processing a
13154              template declaration and this enumeration constant had no
13155              explicit initializer.  */
13156           value = DECL_INITIAL (decl);
13157           if (value && !processing_template_decl)
13158             {
13159               /* Set the TREE_TYPE for the VALUE as well.  That's so
13160                  that when we call decl_constant_value we get an
13161                  entity of the right type (but with the constant
13162                  value).  Since we shouldn't ever call
13163                  decl_constant_value on a template type, there's no
13164                  reason to do that when processing_template_decl.
13165                  And, if the expression is something like a
13166                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13167                  wreak havoc on the intended type of the expression.
13168
13169                  Of course, there's also no point in trying to compute
13170                  minimum or maximum values if we're in a template.  */
13171               TREE_TYPE (value) = enumtype;
13172
13173               if (!minnode)
13174                 minnode = maxnode = value;
13175               else if (tree_int_cst_lt (maxnode, value))
13176                 maxnode = value;
13177               else if (tree_int_cst_lt (value, minnode))
13178                 minnode = value;
13179             }
13180
13181           if (processing_template_decl)
13182             /* If this is just a template, leave the CONST_DECL
13183                alone.  That way tsubst_copy will find CONST_DECLs for
13184                CONST_DECLs, and not INTEGER_CSTs.  */
13185             ;
13186           else
13187             /* In the list we're building up, we want the enumeration
13188                values, not the CONST_DECLs.  */
13189             TREE_VALUE (pair) = value;
13190         }
13191     }
13192   else
13193     maxnode = minnode = integer_zero_node;
13194
13195   TYPE_VALUES (enumtype) = nreverse (values);
13196
13197   if (processing_template_decl)
13198     {
13199       tree scope = current_scope ();
13200       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13201         add_tree (build_min (TAG_DEFN, enumtype));
13202     }
13203   else
13204     {
13205       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13206       int lowprec = min_precision (minnode, unsignedp);
13207       int highprec = min_precision (maxnode, unsignedp);
13208       int precision = MAX (lowprec, highprec);
13209       tree tem;
13210
13211       TYPE_SIZE (enumtype) = NULL_TREE;
13212
13213       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13214
13215       TYPE_PRECISION (enumtype) = precision;
13216       if (unsignedp)
13217         fixup_unsigned_type (enumtype);
13218       else
13219         fixup_signed_type (enumtype);
13220
13221       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13222         /* Use the width of the narrowest normal C type which is wide
13223            enough.  */
13224         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13225                                                     (precision, 1));
13226       else
13227         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13228
13229       TYPE_SIZE (enumtype) = 0;
13230       layout_type (enumtype);
13231
13232       /* Fix up all variant types of this enum type.  */
13233       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13234            tem = TYPE_NEXT_VARIANT (tem))
13235         {
13236           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13237           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13238           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13239           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13240           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13241           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13242           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13243           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13244           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13245           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13246         }
13247
13248       /* Finish debugging output for this type.  */
13249       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13250     }
13251
13252   return enumtype;
13253 }
13254
13255 /* Build and install a CONST_DECL for an enumeration constant of the
13256    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13257    Assignment of sequential values by default is handled here.  */
13258
13259 void
13260 build_enumerator (name, value, enumtype)
13261      tree name;
13262      tree value;
13263      tree enumtype;
13264 {
13265   tree decl;
13266   tree context;
13267   tree type;
13268   tree values;
13269
13270   /* Remove no-op casts from the value.  */
13271   if (value)
13272     STRIP_TYPE_NOPS (value);
13273
13274   if (! processing_template_decl)
13275     {
13276       /* Validate and default VALUE.  */
13277       if (value != NULL_TREE)
13278         {
13279           value = decl_constant_value (value);
13280
13281           if (TREE_CODE (value) == INTEGER_CST)
13282             {
13283               value = default_conversion (value);
13284               constant_expression_warning (value);
13285             }
13286           else
13287             {
13288               cp_error ("enumerator value for `%D' not integer constant", name);
13289               value = NULL_TREE;
13290             }
13291         }
13292
13293       /* Default based on previous value.  */
13294       if (value == NULL_TREE && ! processing_template_decl)
13295         {
13296           tree prev_value;
13297
13298           if (TYPE_VALUES (enumtype))
13299             {
13300               /* The next value is the previous value ... */
13301               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13302               /* ... plus one.  */
13303               value = cp_build_binary_op (PLUS_EXPR,
13304                                           prev_value,
13305                                           integer_one_node);
13306
13307               if (tree_int_cst_lt (value, prev_value))
13308                 cp_error ("overflow in enumeration values at `%D'", name);
13309             }
13310           else
13311             value = integer_zero_node;
13312         }
13313
13314       /* Remove no-op casts from the value.  */
13315       if (value)
13316         STRIP_TYPE_NOPS (value);
13317 #if 0
13318       /* To fix MAX_VAL enum consts. (bkoz)  */
13319       TREE_TYPE (value) = integer_type_node;
13320 #endif
13321     }
13322
13323   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13324      Even in other cases, we will later (in finish_enum) be setting
13325      the type of VALUE.  But, we don't need to make a copy if this
13326      VALUE is one of the enumeration constants for this same
13327      enumeration type.  */
13328   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13329     if (TREE_VALUE (values) == value)
13330       break;
13331   /* If we didn't break out of the loop, then we do need a copy.  */
13332   if (!values && value)
13333     value = copy_node (value);
13334
13335   /* C++ associates enums with global, function, or class declarations.  */
13336   context = current_scope ();
13337
13338   /* Build the actual enumeration constant.  Note that the enumeration
13339     constants have the type of their initializers until the
13340     enumeration is complete:
13341
13342       [ dcl.enum ]
13343
13344       Following the closing brace of an enum-specifier, each enumer-
13345       ator has the type of its enumeration.  Prior to the closing
13346       brace, the type of each enumerator is the type of its
13347       initializing value.
13348
13349     In finish_enum we will reset the type.  Of course, if we're
13350     processing a template, there may be no value.   */
13351   type = value ? TREE_TYPE (value) : NULL_TREE;
13352
13353   if (context && context == current_class_type)
13354     /* This enum declaration is local to the class.  We need the full
13355       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13356     decl = build_lang_decl (CONST_DECL, name, type);
13357   else
13358     /* It's a global enum, or it's local to a function.  (Note local to
13359       a function could mean local to a class method.  */
13360     decl = build_decl (CONST_DECL, name, type);
13361
13362   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13363   DECL_INITIAL (decl) = value;
13364   TREE_READONLY (decl) = 1;
13365
13366   if (context && context == current_class_type)
13367     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13368       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13369       things like `S::i' later.)  */
13370     finish_member_declaration (decl);
13371   else
13372     {
13373       pushdecl (decl);
13374       GNU_xref_decl (current_function_decl, decl);
13375     }
13376
13377   /* Add this enumeration constant to the list for this type.  */
13378   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13379 }
13380
13381 \f
13382 /* We're defining DECL.  Make sure that it's type is OK.  */
13383
13384 static void
13385 check_function_type (decl)
13386      tree decl;
13387 {
13388   tree fntype = TREE_TYPE (decl);
13389   tree return_type = complete_type (TREE_TYPE (fntype));
13390
13391   /* In a function definition, arg types must be complete.  */
13392   require_complete_types_for_parms (current_function_parms);
13393
13394   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13395     {
13396       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13397
13398       /* Make it return void instead, but don't change the
13399          type of the DECL_RESULT, in case we have a named return value.  */
13400       if (TREE_CODE (fntype) == METHOD_TYPE)
13401         {
13402           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13403           TREE_TYPE (decl)
13404             = build_cplus_method_type (ctype,
13405                                        void_type_node,
13406                                        FUNCTION_ARG_CHAIN (decl));
13407         }
13408       else
13409         TREE_TYPE (decl)
13410           = build_function_type (void_type_node,
13411                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13412       TREE_TYPE (decl)
13413         = build_exception_variant (fntype,
13414                                    TYPE_RAISES_EXCEPTIONS (fntype));
13415     }
13416   else
13417     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13418 }
13419
13420 /* Create the FUNCTION_DECL for a function definition.
13421    DECLSPECS and DECLARATOR are the parts of the declaration;
13422    they describe the function's name and the type it returns,
13423    but twisted together in a fashion that parallels the syntax of C.
13424
13425    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13426    DECLARATOR is really the DECL for the function we are about to
13427    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13428    indicating that the function is an inline defined in-class, and
13429    SF_EXPAND indicating that we should generate RTL for this
13430    function.
13431
13432    This function creates a binding context for the function body
13433    as well as setting up the FUNCTION_DECL in current_function_decl.
13434
13435    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13436    (it defines a datum instead), we return 0, which tells
13437    yyparse to report a parse error.
13438
13439    For C++, we must first check whether that datum makes any sense.
13440    For example, "class A local_a(1,2);" means that variable local_a
13441    is an aggregate of type A, which should have a constructor
13442    applied to it with the argument list [1, 2].  */
13443
13444 int
13445 start_function (declspecs, declarator, attrs, flags)
13446      tree declspecs, declarator, attrs;
13447      int flags;
13448 {
13449   tree decl1;
13450   tree ctype = NULL_TREE;
13451   tree fntype;
13452   tree restype;
13453   extern int have_extern_spec;
13454   extern int used_extern_spec;
13455   int doing_friend = 0;
13456   struct binding_level *bl;
13457
13458   /* Sanity check.  */
13459   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13460   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13461
13462   /* This should only be done once on the top most decl.  */
13463   if (have_extern_spec && !used_extern_spec)
13464     {
13465       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13466       used_extern_spec = 1;
13467     }
13468
13469   if (flags & SF_PRE_PARSED)
13470     {
13471       decl1 = declarator;
13472
13473       fntype = TREE_TYPE (decl1);
13474       if (TREE_CODE (fntype) == METHOD_TYPE)
13475         ctype = TYPE_METHOD_BASETYPE (fntype);
13476
13477       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13478          the (lexical) scope of the class in which it is defined.  */
13479       if (!ctype && DECL_FRIEND_P (decl1))
13480         {
13481           ctype = DECL_FRIEND_CONTEXT (decl1);
13482
13483           /* CTYPE could be null here if we're dealing with a template;
13484              for example, `inline friend float foo()' inside a template
13485              will have no CTYPE set.  */
13486           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13487             ctype = NULL_TREE;
13488           else
13489             doing_friend = 1;
13490         }
13491
13492       last_function_parms = DECL_ARGUMENTS (decl1);
13493       last_function_parm_tags = NULL_TREE;
13494     }
13495   else
13496     {
13497       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13498       /* If the declarator is not suitable for a function definition,
13499          cause a syntax error.  */
13500       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13501
13502       fntype = TREE_TYPE (decl1);
13503
13504       restype = TREE_TYPE (fntype);
13505       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13506         {
13507           cp_error ("semicolon missing after declaration of `%#T'", restype);
13508           shadow_tag (build_tree_list (NULL_TREE, restype));
13509           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13510           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13511             fntype = build_function_type (integer_type_node,
13512                                           TYPE_ARG_TYPES (fntype));
13513           else
13514             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13515                                               integer_type_node,
13516                                               TYPE_ARG_TYPES (fntype));
13517           TREE_TYPE (decl1) = fntype;
13518         }
13519
13520       if (TREE_CODE (fntype) == METHOD_TYPE)
13521         ctype = TYPE_METHOD_BASETYPE (fntype);
13522       else if (DECL_MAIN_P (decl1))
13523         {
13524           /* If this doesn't return integer_type, complain.  */
13525           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13526             {
13527               if (pedantic || warn_return_type)
13528                 pedwarn ("return type for `main' changed to `int'");
13529               TREE_TYPE (decl1) = fntype = default_function_type;
13530             }
13531         }
13532     }
13533
13534   /* Sometimes we don't notice that a function is a static member, and
13535      build a METHOD_TYPE for it.  Fix that up now.  */
13536   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13537       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13538     {
13539       revert_static_member_fn (decl1);
13540       last_function_parms = TREE_CHAIN (last_function_parms);
13541       ctype = NULL_TREE;
13542     }
13543
13544   /* Warn if function was previously implicitly declared
13545      (but not if we warned then).  */
13546   if (! warn_implicit
13547       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13548     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13549
13550   /* Set up current_class_type, and enter the scope of the class, if
13551      appropriate.  */
13552   if (ctype)
13553     push_nested_class (ctype, 1);
13554   else if (DECL_STATIC_FUNCTION_P (decl1))
13555     push_nested_class (DECL_CONTEXT (decl1), 2);
13556
13557   /* Now that we have entered the scope of the class, we must restore
13558      the bindings for any template parameters surrounding DECL1, if it
13559      is an inline member template.  (Order is important; consider the
13560      case where a template parameter has the same name as a field of
13561      the class.)  It is not until after this point that
13562      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13563   if (flags & SF_INCLASS_INLINE)
13564     maybe_begin_member_template_processing (decl1);
13565
13566   /* Effective C++ rule 15.  See also c_expand_return.  */
13567   if (warn_ecpp
13568       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13569       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13570     cp_warning ("`operator=' should return a reference to `*this'");
13571
13572   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13573      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13574   if (!DECL_INITIAL (decl1))
13575     DECL_INITIAL (decl1) = error_mark_node;
13576
13577 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13578   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13579 #endif
13580
13581   /* This function exists in static storage.
13582      (This does not mean `static' in the C sense!)  */
13583   TREE_STATIC (decl1) = 1;
13584
13585   /* We must call push_template_decl after current_class_type is set
13586      up.  (If we are processing inline definitions after exiting a
13587      class scope, current_class_type will be NULL_TREE until set above
13588      by push_nested_class.)  */
13589   if (processing_template_decl)
13590     decl1 = push_template_decl (decl1);
13591
13592   /* We are now in the scope of the function being defined.  */
13593   current_function_decl = decl1;
13594
13595   /* Save the parm names or decls from this function's declarator
13596      where store_parm_decls will find them.  */
13597   current_function_parms = last_function_parms;
13598   current_function_parm_tags = last_function_parm_tags;
13599
13600   /* Make sure the parameter and return types are reasonable.  When
13601      you declare a function, these types can be incomplete, but they
13602      must be complete when you define the function.  */
13603   if (! processing_template_decl)
13604     check_function_type (decl1);
13605
13606   /* Build the return declaration for the function.  */
13607   restype = TREE_TYPE (fntype);
13608   if (!processing_template_decl)
13609     {
13610       if (!DECL_RESULT (decl1))
13611         {
13612           DECL_RESULT (decl1)
13613             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13614           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13615                                       DECL_RESULT (decl1));
13616         }
13617     }
13618   else
13619     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13620     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13621
13622   /* Initialize RTL machinery.  We cannot do this until
13623      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13624      even when processing a template; this is how we get
13625      CFUN set up, and our per-function variables initialized.  */
13626   bl = current_binding_level;
13627   init_function_start (decl1, input_filename, lineno);
13628   current_binding_level = bl;
13629   expanding_p = (flags & SF_EXPAND) != 0;
13630
13631   /* Even though we're inside a function body, we still don't want to
13632      call expand_expr to calculate the size of a variable-sized array.
13633      We haven't necessarily assigned RTL to all variables yet, so it's
13634      not safe to try to expand expressions involving them.  */
13635   immediate_size_expand = 0;
13636   cfun->x_dont_save_pending_sizes_p = 1;
13637
13638   /* If we're building a statement-tree, start the tree now.  */
13639   if (processing_template_decl || !expanding_p)
13640     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13641
13642   /* Let the user know we're compiling this function.  */
13643   announce_function (decl1);
13644
13645   /* Record the decl so that the function name is defined.
13646      If we already have a decl for this name, and it is a FUNCTION_DECL,
13647      use the old decl.  */
13648   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13649     {
13650       /* A specialization is not used to guide overload resolution.  */
13651       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13652           && ! DECL_FUNCTION_MEMBER_P (decl1))
13653         decl1 = pushdecl (decl1);
13654       else
13655         {
13656           /* We need to set the DECL_CONTEXT. */
13657           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13658             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13659           /* And make sure we have enough default args.  */
13660           check_default_args (decl1);
13661         }
13662       fntype = TREE_TYPE (decl1);
13663     }
13664
13665   /* Reset these in case the call to pushdecl changed them.  */
13666   current_function_decl = decl1;
13667   cfun->decl = decl1;
13668
13669   /* Initialize the per-function data.  */
13670   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13671     {
13672       /* If we already parsed this function, and we're just expanding it
13673          now, restore saved state.  */
13674       struct binding_level *bl = current_binding_level;
13675       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13676       current_binding_level = bl;
13677
13678       /* This function is being processed in whole-function mode; we
13679          already did semantic analysis.  */
13680       cfun->x_whole_function_mode_p = 1;
13681
13682       /* If we decided that we didn't want to inline this function,
13683          make sure the back-end knows that.  */
13684       if (!current_function_cannot_inline)
13685         current_function_cannot_inline = cp_function_chain->cannot_inline;
13686
13687       /* We don't need the saved data anymore.  */
13688       free (DECL_SAVED_FUNCTION_DATA (decl1));
13689       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13690     }
13691   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13692     {
13693       /* We know that this was set up by `grokclassfn'.  We do not
13694          wait until `store_parm_decls', since evil parse errors may
13695          never get us to that point.  Here we keep the consistency
13696          between `current_class_type' and `current_class_ptr'.  */
13697       tree t = DECL_ARGUMENTS (decl1);
13698
13699       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13700                           162);
13701       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13702                           19990811);
13703
13704       cp_function_chain->x_current_class_ref
13705         = build_indirect_ref (t, NULL_PTR);
13706       cp_function_chain->x_current_class_ptr = t;
13707
13708       /* Constructors and destructors need to know whether they're "in
13709          charge" of initializing virtual base classes.  */
13710       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13711         current_in_charge_parm = TREE_CHAIN (t);
13712     }
13713
13714   if (DECL_INTERFACE_KNOWN (decl1))
13715     {
13716       tree ctx = decl_function_context (decl1);
13717
13718       if (DECL_NOT_REALLY_EXTERN (decl1))
13719         DECL_EXTERNAL (decl1) = 0;
13720
13721       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13722           && TREE_PUBLIC (ctx))
13723         /* This is a function in a local class in an extern inline
13724            function.  */
13725         comdat_linkage (decl1);
13726     }
13727   /* If this function belongs to an interface, it is public.
13728      If it belongs to someone else's interface, it is also external.
13729      This only affects inlines and template instantiations.  */
13730   else if (interface_unknown == 0
13731            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13732                || flag_alt_external_templates))
13733     {
13734       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13735           || processing_template_decl)
13736         {
13737           DECL_EXTERNAL (decl1)
13738             = (interface_only
13739                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13740                    && !DECL_VINDEX (decl1)));
13741
13742           /* For WIN32 we also want to put these in linkonce sections.  */
13743           maybe_make_one_only (decl1);
13744         }
13745       else
13746         DECL_EXTERNAL (decl1) = 0;
13747       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13748       DECL_INTERFACE_KNOWN (decl1) = 1;
13749     }
13750   else if (interface_unknown && interface_only
13751            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13752                || flag_alt_external_templates))
13753     {
13754       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13755          interface, we will have interface_only set but not
13756          interface_known.  In that case, we don't want to use the normal
13757          heuristics because someone will supply a #pragma implementation
13758          elsewhere, and deducing it here would produce a conflict.  */
13759       comdat_linkage (decl1);
13760       DECL_EXTERNAL (decl1) = 0;
13761       DECL_INTERFACE_KNOWN (decl1) = 1;
13762       DECL_DEFER_OUTPUT (decl1) = 1;
13763     }
13764   else
13765     {
13766       /* This is a definition, not a reference.
13767          So clear DECL_EXTERNAL.  */
13768       DECL_EXTERNAL (decl1) = 0;
13769
13770       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13771           && ! DECL_INTERFACE_KNOWN (decl1)
13772           /* Don't try to defer nested functions for now.  */
13773           && ! decl_function_context (decl1))
13774         DECL_DEFER_OUTPUT (decl1) = 1;
13775       else
13776         DECL_INTERFACE_KNOWN (decl1) = 1;
13777     }
13778
13779   if (doing_semantic_analysis_p ())
13780     {
13781       pushlevel (0);
13782       current_binding_level->parm_flag = 1;
13783     }
13784
13785   if (attrs)
13786     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13787
13788   if (!building_stmt_tree ())
13789     {
13790       GNU_xref_function (decl1, current_function_parms);
13791       make_function_rtl (decl1);
13792     }
13793
13794   /* Promote the value to int before returning it.  */
13795   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13796     restype = type_promotes_to (restype);
13797
13798   /* If this fcn was already referenced via a block-scope `extern' decl
13799      (or an implicit decl), propagate certain information about the usage.  */
13800   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13801     TREE_ADDRESSABLE (decl1) = 1;
13802
13803   if (DECL_RESULT (decl1) == NULL_TREE)
13804     {
13805       DECL_RESULT (decl1)
13806         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13807       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13808       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13809     }
13810
13811   ++function_depth;
13812
13813   if (DECL_DESTRUCTOR_P (decl1))
13814     {
13815       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13816       DECL_CONTEXT (dtor_label) = current_function_decl;
13817     }
13818   /* Under the old ABI we return `this' from constructors, so we make
13819      ordinary `return' statements in constructors jump to CTOR_LABEL;
13820      from there we return `this'.  Under the new ABI, we don't bother
13821      with any of this.  By not setting CTOR_LABEL the remainder of the
13822      machinery is automatically disabled.  */
13823   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13824     {
13825       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13826       DECL_CONTEXT (ctor_label) = current_function_decl;
13827     }
13828
13829   return 1;
13830 }
13831 \f
13832 /* Called after store_parm_decls for a function-try-block.  */
13833
13834 void
13835 expand_start_early_try_stmts ()
13836 {
13837   expand_start_try_stmts ();
13838 }
13839
13840 /* Store the parameter declarations into the current function declaration.
13841    This is called after parsing the parameter declarations, before
13842    digesting the body of the function.
13843
13844    Also install to binding contour return value identifier, if any.  */
13845
13846 void
13847 store_parm_decls ()
13848 {
13849   register tree fndecl = current_function_decl;
13850   register tree parm;
13851   int parms_have_cleanups = 0;
13852   tree cleanups = NULL_TREE;
13853
13854   /* This is a list of types declared among parms in a prototype.  */
13855   tree parmtags = current_function_parm_tags;
13856
13857   /* This is a chain of any other decls that came in among the parm
13858      declarations.  If a parm is declared with  enum {foo, bar} x;
13859      then CONST_DECLs for foo and bar are put here.  */
13860   tree nonparms = NULL_TREE;
13861
13862   /* Create a binding level for the parms.  */
13863   if (!building_stmt_tree ())
13864     expand_start_bindings (2);
13865
13866   if (current_function_parms)
13867     {
13868       /* This case is when the function was defined with an ANSI prototype.
13869          The parms already have decls, so we need not do anything here
13870          except record them as in effect
13871          and complain if any redundant old-style parm decls were written.  */
13872
13873       tree specparms = current_function_parms;
13874       tree next;
13875
13876       if (doing_semantic_analysis_p ())
13877         {
13878           /* Must clear this because it might contain TYPE_DECLs declared
13879              at class level.  */
13880           storedecls (NULL_TREE);
13881
13882           /* If we're doing semantic analysis, then we'll call pushdecl
13883              for each of these.  We must do them in reverse order so that
13884              they end in the correct forward order.  */
13885           specparms = nreverse (specparms);
13886         }
13887
13888       for (parm = specparms; parm; parm = next)
13889         {
13890           next = TREE_CHAIN (parm);
13891           if (TREE_CODE (parm) == PARM_DECL)
13892             {
13893               tree type = TREE_TYPE (parm);
13894
13895               if (doing_semantic_analysis_p ())
13896                 {
13897                   tree cleanup;
13898
13899                   if (DECL_NAME (parm) == NULL_TREE
13900                       || TREE_CODE (parm) != VOID_TYPE)
13901                     pushdecl (parm);
13902                   else
13903                     cp_error ("parameter `%D' declared void", parm);
13904
13905                   cleanup = (processing_template_decl
13906                              ? NULL_TREE
13907                              : maybe_build_cleanup (parm));
13908
13909                   if (cleanup)
13910                     cleanups = tree_cons (parm, cleanup, cleanups);
13911                 }
13912               else if (type != error_mark_node
13913                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13914                 parms_have_cleanups = 1;
13915             }
13916           else
13917             {
13918               /* If we find an enum constant or a type tag,
13919                  put it aside for the moment.  */
13920               TREE_CHAIN (parm) = NULL_TREE;
13921               nonparms = chainon (nonparms, parm);
13922             }
13923         }
13924
13925       if (doing_semantic_analysis_p ())
13926         {
13927           /* Get the decls in their original chain order
13928              and record in the function.  This is all and only the
13929              PARM_DECLs that were pushed into scope by the loop above.  */
13930           DECL_ARGUMENTS (fndecl) = getdecls ();
13931           storetags (chainon (parmtags, gettags ()));
13932         }
13933     }
13934   else
13935     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13936
13937   /* Now store the final chain of decls for the arguments
13938      as the decl-chain of the current lexical scope.
13939      Put the enumerators in as well, at the front so that
13940      DECL_ARGUMENTS is not modified.  */
13941   if (doing_semantic_analysis_p ())
13942     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13943
13944   /* Initialize the RTL code for the function.  */
13945   DECL_SAVED_INSNS (fndecl) = 0;
13946   if (! building_stmt_tree ())
13947     expand_function_start (fndecl, parms_have_cleanups);
13948
13949   current_function_parms_stored = 1;
13950
13951   /* If this function is `main', emit a call to `__main'
13952      to run global initializers, etc.  */
13953   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13954     expand_main_function ();
13955
13956   /* Now that we have initialized the parms, we can start their
13957      cleanups.  We cannot do this before, since expand_decl_cleanup
13958      should not be called before the parm can be used.  */
13959   while (cleanups)
13960     {
13961       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13962                            TREE_VALUE (cleanups));
13963       cleanups = TREE_CHAIN (cleanups);
13964     }
13965
13966   /* Create a binding contour which can be used to catch
13967      cleanup-generated temporaries.  Also, if the return value needs or
13968      has initialization, deal with that now.  */
13969   if (parms_have_cleanups)
13970     {
13971       pushlevel (0);
13972       if (!building_stmt_tree ())
13973         expand_start_bindings (2);
13974     }
13975
13976   /* Do the starting of the exception specifications, if we have any.  */
13977   if (flag_exceptions && !processing_template_decl
13978       && flag_enforce_eh_specs
13979       && building_stmt_tree ()
13980       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13981     current_eh_spec_try_block = expand_start_eh_spec ();
13982 }
13983
13984 /* Bind a name and initialization to the return value of
13985    the current function.  */
13986
13987 void
13988 store_return_init (decl)
13989      tree decl;
13990 {
13991   /* If this named return value comes in a register, put it in a
13992      pseudo-register.  */
13993   if (DECL_REGISTER (decl))
13994     {
13995       original_result_rtx = DECL_RTL (decl);
13996       /* Note that the mode of the old DECL_RTL may be wider than the
13997          mode of DECL_RESULT, depending on the calling conventions for
13998          the processor.  For example, on the Alpha, a 32-bit integer
13999          is returned in a DImode register -- the DECL_RESULT has
14000          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
14001          here, we use the mode the back-end has already assigned for
14002          the return value.  */
14003       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
14004       if (TREE_ADDRESSABLE (decl))
14005         put_var_into_stack (decl);
14006     }
14007 }
14008
14009 \f
14010 /* We have finished doing semantic analysis on DECL, but have not yet
14011    generated RTL for its body.  Save away our current state, so that
14012    when we want to generate RTL later we know what to do.  */
14013
14014 static void
14015 save_function_data (decl)
14016      tree decl;
14017 {
14018   struct language_function *f;
14019
14020   /* Save the language-specific per-function data so that we can
14021      get it back when we really expand this function.  */
14022   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14023                       19990908);
14024
14025   /* Make a copy.  */
14026   f = ((struct language_function *)
14027        xmalloc (sizeof (struct language_function)));
14028   bcopy ((char *) cp_function_chain, (char *) f,
14029          sizeof (struct language_function));
14030   DECL_SAVED_FUNCTION_DATA (decl) = f;
14031
14032   /* Clear out the bits we don't need.  */
14033   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14034   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14035   f->x_result_rtx = NULL_RTX;
14036   f->x_named_label_uses = NULL;
14037   f->bindings = NULL;
14038
14039   /* When we get back here again, we will be expanding.  */
14040   f->x_expanding_p = 1;
14041
14042   /* If we've already decided that we cannot inline this function, we
14043      must remember that fact when we actually go to expand the
14044      function.  */
14045   f->cannot_inline = current_function_cannot_inline;
14046 }
14047
14048 /* At the end of every constructor we generate to code to return
14049    `this'.  Do that now.  */
14050
14051 static void
14052 finish_constructor_body ()
14053 {
14054   /* Any return from a constructor will end up here.  */
14055   if (ctor_label)
14056     add_tree (build_stmt (LABEL_STMT, ctor_label));
14057
14058   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14059      generate the return, rather than a goto to CTOR_LABEL.  */
14060   ctor_label = NULL_TREE;
14061   /* In check_return_expr we translate an empty return from a
14062      constructor to a return of `this'.  */
14063   finish_return_stmt (NULL_TREE);
14064   /* Mark the end of the constructor.  */
14065   add_tree (build_stmt (CTOR_STMT));
14066 }
14067
14068 /* At the end of every destructor we generate code to restore virtual
14069    function tables to the values desired by base classes and to call
14070    to base class destructors.  Do that now.  */
14071
14072 static void
14073 finish_destructor_body ()
14074 {
14075   tree compound_stmt;
14076   tree virtual_size;
14077   tree exprstmt;
14078   tree if_stmt;
14079
14080   /* Create a block to contain all the extra code.  */
14081   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14082
14083   /* Any return from a destructor will end up here.  */
14084   add_tree (build_stmt (LABEL_STMT, dtor_label));
14085
14086   /* Generate the code to call destructor on base class.  If this
14087      destructor belongs to a class with virtual functions, then set
14088      the virtual function table pointer to represent the type of our
14089      base class.  */
14090
14091   /* This side-effect makes call to `build_delete' generate the code
14092      we have to have at the end of this destructor.  `build_delete'
14093      will set the flag again.  */
14094   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14095
14096   exprstmt = build_delete (current_class_type,
14097                            current_class_ref,
14098                            sfk_base_destructor,
14099                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14100                            0);
14101
14102   if (exprstmt != error_mark_node
14103       && (TREE_CODE (exprstmt) != NOP_EXPR
14104           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14105           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14106     {
14107       if (exprstmt != void_zero_node)
14108         /* Don't call `expand_expr_stmt' if we're not going to do
14109            anything, since -Wall will give a diagnostic.  */
14110         finish_expr_stmt (exprstmt);
14111
14112       /* Run destructors for all virtual baseclasses.  */
14113       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14114         {
14115           tree vbases;
14116           tree if_stmt;
14117
14118           if_stmt = begin_if_stmt ();
14119           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14120                                       current_in_charge_parm,
14121                                       integer_two_node),
14122                                if_stmt);
14123
14124           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14125           /* The CLASSTYPE_VBASECLASSES list is in initialization
14126              order, so we have to march through it in reverse order.  */
14127           for (vbases = nreverse (copy_list (vbases));
14128                vbases;
14129                vbases = TREE_CHAIN (vbases))
14130             {
14131               tree vbase = TREE_VALUE (vbases);
14132
14133               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14134                 {
14135                   tree vb = get_vbase
14136                     (BINFO_TYPE (vbase),
14137                      TYPE_BINFO (current_class_type));
14138                   finish_expr_stmt
14139                     (build_scoped_method_call
14140                      (current_class_ref, vb, base_dtor_identifier,
14141                       NULL_TREE));
14142                 }
14143             }
14144
14145           finish_then_clause (if_stmt);
14146           finish_if_stmt ();
14147         }
14148     }
14149
14150   virtual_size = c_sizeof (current_class_type);
14151
14152   /* At the end, call delete if that's what's requested.  */
14153
14154   /* FDIS sez: At the point of definition of a virtual destructor
14155      (including an implicit definition), non-placement operator delete
14156      shall be looked up in the scope of the destructor's class and if
14157      found shall be accessible and unambiguous.
14158
14159      This is somewhat unclear, but I take it to mean that if the class
14160      only defines placement deletes we don't do anything here.  So we
14161      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14162      they ever try to delete one of these.  */
14163   exprstmt = build_op_delete_call
14164     (DELETE_EXPR, current_class_ptr, virtual_size,
14165      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14166
14167   if_stmt = begin_if_stmt ();
14168   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14169                               current_in_charge_parm,
14170                               integer_one_node),
14171                        if_stmt);
14172   finish_expr_stmt (exprstmt);
14173   finish_then_clause (if_stmt);
14174   finish_if_stmt ();
14175
14176   /* Close the block we started above.  */
14177   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14178 }
14179
14180 /* Finish up a function declaration and compile that function
14181    all the way to assembler language output.  The free the storage
14182    for the function definition.
14183
14184    FLAGS is a bitwise or of the following values:
14185      1 - CALL_POPLEVEL
14186        An extra call to poplevel (and expand_end_bindings) must be
14187        made to take care of the binding contour for the base
14188        initializers.  This is only relevant for constructors.
14189      2 - INCLASS_INLINE
14190        We just finished processing the body of an in-class inline
14191        function definition.  (This processing will have taken place
14192        after the class definition is complete.)  */
14193
14194 tree
14195 finish_function (flags)
14196      int flags;
14197 {
14198   register tree fndecl = current_function_decl;
14199   tree fntype, ctype = NULL_TREE;
14200   /* Label to use if this function is supposed to return a value.  */
14201   tree no_return_label = NULL_TREE;
14202   int call_poplevel = (flags & 1) != 0;
14203   int inclass_inline = (flags & 2) != 0;
14204   int expand_p;
14205   int nested;
14206   int current_line = lineno;
14207
14208   /* When we get some parse errors, we can end up without a
14209      current_function_decl, so cope.  */
14210   if (fndecl == NULL_TREE)
14211     return error_mark_node;
14212
14213   nested = function_depth > 1;
14214   fntype = TREE_TYPE (fndecl);
14215
14216   /*  TREE_READONLY (fndecl) = 1;
14217       This caused &foo to be of type ptr-to-const-function
14218       which then got a warning when stored in a ptr-to-function variable.  */
14219
14220   /* This happens on strange parse errors.  */
14221   if (! current_function_parms_stored)
14222     {
14223       call_poplevel = 0;
14224       store_parm_decls ();
14225     }
14226
14227   /* For a cloned function, we've already got all the code we need;
14228      there's no need to add any extra bits.  */
14229   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14230     ;
14231   else if (building_stmt_tree ())
14232     {
14233       if (DECL_CONSTRUCTOR_P (fndecl))
14234         {
14235           finish_constructor_body ();
14236           if (call_poplevel)
14237             do_poplevel ();
14238         }
14239       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14240         finish_destructor_body ();
14241       else if (DECL_MAIN_P (fndecl))
14242         {
14243           /* Make it so that `main' always returns 0 by default.  */
14244 #ifdef VMS
14245           finish_return_stmt (integer_one_node);
14246 #else
14247           finish_return_stmt (integer_zero_node);
14248 #endif
14249         }
14250
14251       /* Finish dealing with exception specifiers.  */
14252       if (flag_exceptions && !processing_template_decl
14253           && flag_enforce_eh_specs
14254           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14255         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14256                             (TREE_TYPE (current_function_decl)),
14257                             current_eh_spec_try_block);
14258     }
14259   else
14260     {
14261 #if 0
14262       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14263         {
14264           /* Keep this code around in case we later want to control debug info
14265              based on whether a type is "used".  (jason 1999-11-11) */
14266
14267           tree ttype = target_type (fntype);
14268           tree parmdecl;
14269
14270           if (IS_AGGR_TYPE (ttype))
14271             /* Let debugger know it should output info for this type.  */
14272             note_debug_info_needed (ttype);
14273
14274           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14275             {
14276               ttype = target_type (TREE_TYPE (parmdecl));
14277               if (IS_AGGR_TYPE (ttype))
14278                 /* Let debugger know it should output info for this type.  */
14279                 note_debug_info_needed (ttype);
14280             }
14281         }
14282 #endif
14283
14284       /* Clean house because we will need to reorder insns here.  */
14285       do_pending_stack_adjust ();
14286
14287       if (dtor_label)
14288         ;
14289       else if (DECL_CONSTRUCTOR_P (fndecl))
14290         {
14291           if (call_poplevel)
14292             do_poplevel ();
14293         }
14294       else if (return_label != NULL_RTX
14295                && flag_this_is_variable <= 0
14296                && current_function_return_value == NULL_TREE
14297                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14298         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14299
14300       if (flag_exceptions)
14301         expand_exception_blocks ();
14302
14303       /* If this function is supposed to return a value, ensure that
14304          we do not fall into the cleanups by mistake.  The end of our
14305          function will look like this:
14306
14307          user code (may have return stmt somewhere)
14308          goto no_return_label
14309          cleanup_label:
14310          cleanups
14311          goto return_label
14312          no_return_label:
14313          NOTE_INSN_FUNCTION_END
14314          return_label:
14315          things for return
14316
14317          If the user omits a return stmt in the USER CODE section, we
14318          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14319          Otherwise, we won't.  */
14320       if (no_return_label)
14321         {
14322           DECL_CONTEXT (no_return_label) = fndecl;
14323           DECL_INITIAL (no_return_label) = error_mark_node;
14324           DECL_SOURCE_FILE (no_return_label) = input_filename;
14325           DECL_SOURCE_LINE (no_return_label) = current_line;
14326           expand_goto (no_return_label);
14327         }
14328
14329       if (cleanup_label)
14330         {
14331           /* Remove the binding contour which is used
14332              to catch cleanup-generated temporaries.  */
14333           expand_end_bindings (0, 0, 0);
14334           poplevel (0, 0, 0);
14335
14336           /* Emit label at beginning of cleanup code for parameters.  */
14337           emit_label (cleanup_label);
14338         }
14339
14340       /* Get return value into register if that's where it's supposed
14341          to be.  */
14342       if (original_result_rtx)
14343         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14344
14345       /* Finish building code that will trigger warnings if users forget
14346          to make their functions return values.  */
14347       if (no_return_label || cleanup_label)
14348         emit_jump (return_label);
14349       if (no_return_label)
14350         {
14351           /* We don't need to call `expand_*_return' here because we
14352              don't need any cleanups here--this path of code is only
14353              for error checking purposes.  */
14354           expand_label (no_return_label);
14355         }
14356
14357       /* We hard-wired immediate_size_expand to zero in
14358          start_function.  Expand_function_end will decrement this
14359          variable.  So, we set the variable to one here, so that after
14360          the decrement it will remain zero.  */
14361       immediate_size_expand = 1;
14362
14363       /* Generate rtl for function exit.  */
14364       expand_function_end (input_filename, current_line, 1);
14365     }
14366
14367   /* We have to save this value here in case
14368      maybe_end_member_template_processing decides to pop all the
14369      template parameters.  */
14370   expand_p = !building_stmt_tree ();
14371
14372   /* If we're saving up tree structure, tie off the function now.  */
14373   if (!expand_p)
14374     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14375
14376   /* This must come after expand_function_end because cleanups might
14377      have declarations (from inline functions) that need to go into
14378      this function's blocks.  */
14379   if (doing_semantic_analysis_p ())
14380     {
14381       if (current_binding_level->parm_flag != 1)
14382         my_friendly_abort (122);
14383       poplevel (1, 0, 1);
14384     }
14385
14386   /* Remember that we were in class scope.  */
14387   if (current_class_name)
14388     ctype = current_class_type;
14389
14390   /* Must mark the RESULT_DECL as being in this function.  */
14391   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14392
14393   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14394      to the FUNCTION_DECL node itself.  */
14395   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14396
14397   /* Save away current state, if appropriate.  */
14398   if (!expanding_p && !processing_template_decl)
14399     save_function_data (fndecl);
14400
14401   /* If this function calls `setjmp' it cannot be inlined.  When
14402      `longjmp' is called it is not guaranteed to restore the value of
14403      local variables that have been modified since the call to
14404      `setjmp'.  So, if were to inline this function into some caller
14405      `c', then when we `longjmp', we might not restore all variables
14406      in `c'.  (It might seem, at first blush, that there's no way for
14407      this function to modify local variables in `c', but their
14408      addresses may have been stored somewhere accessible to this
14409      function.)  */
14410   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14411     DECL_UNINLINABLE (fndecl) = 1;
14412
14413   if (expand_p)
14414     {
14415       int returns_null;
14416       int returns_value;
14417
14418       /* So we can tell if jump_optimize sets it to 1.  */
14419       can_reach_end = 0;
14420
14421       /* Before we call rest_of_compilation (which will pop the
14422          CURRENT_FUNCTION), we must save these values.  */
14423       returns_null = current_function_returns_null;
14424       returns_value = current_function_returns_value;
14425
14426       /* If this is a nested function (like a template instantiation
14427          that we're compiling in the midst of compiling something
14428          else), push a new GC context.  That will keep local variables
14429          on the stack from being collected while we're doing the
14430          compilation of this function.  */
14431       if (function_depth > 1)
14432         ggc_push_context ();
14433
14434       /* Run the optimizers and output the assembler code for this
14435          function.  */
14436       rest_of_compilation (fndecl);
14437
14438       /* Undo the call to ggc_push_context above.  */
14439       if (function_depth > 1)
14440         ggc_pop_context ();
14441
14442       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14443         {
14444           /* Set DECL_EXTERNAL so that assemble_external will be called as
14445              necessary.  We'll clear it again in finish_file.  */
14446           if (! DECL_EXTERNAL (fndecl))
14447             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14448           DECL_EXTERNAL (fndecl) = 1;
14449           defer_fn (fndecl);
14450         }
14451
14452 #if 0
14453       /* Keep this code around in case we later want to control debug info
14454          based on whether a type is "used".  (jason 1999-11-11) */
14455
14456       if (ctype && TREE_ASM_WRITTEN (fndecl))
14457         note_debug_info_needed (ctype);
14458 #endif
14459
14460       if (DECL_NAME (DECL_RESULT (fndecl)))
14461         returns_value |= can_reach_end;
14462       else
14463         returns_null |= can_reach_end;
14464
14465       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14466         warning ("`noreturn' function does return");
14467       else if (returns_null
14468                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14469         {
14470           /* Always complain if there's just no return statement.  */
14471           if (!returns_value)
14472             warning ("no return statement in function returning non-void");
14473           else if (warn_return_type || pedantic)
14474             /* If this function returns non-void and control can drop through,
14475                complain.  */
14476             warning ("control reaches end of non-void function");
14477         }
14478     }
14479   else
14480     {
14481       /* Clear out memory we no longer need.  */
14482       free_after_parsing (cfun);
14483       /* Since we never call rest_of_compilation, we never clear
14484          CFUN.  Do so explicitly.  */
14485       free_after_compilation (cfun);
14486       cfun = NULL;
14487     }
14488
14489   /* If this is a in-class inline definition, we may have to pop the
14490      bindings for the template parameters that we added in
14491      maybe_begin_member_template_processing when start_function was
14492      called.  */
14493   if (inclass_inline)
14494     maybe_end_member_template_processing ();
14495
14496   /* Leave the scope of the class.  */
14497   if (ctype)
14498     pop_nested_class ();
14499
14500   --function_depth;
14501
14502   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14503       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14504     {
14505       tree t;
14506
14507       /* Stop pointing to the local nodes about to be freed.  */
14508       /* But DECL_INITIAL must remain nonzero so we know this
14509          was an actual function definition.  */
14510       DECL_INITIAL (fndecl) = error_mark_node;
14511       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14512         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14513     }
14514
14515   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14516     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14517   if (DECL_STATIC_DESTRUCTOR (fndecl))
14518     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14519
14520   /* Clean up.  */
14521   if (! nested)
14522     {
14523       /* Let the error reporting routines know that we're outside a
14524          function.  For a nested function, this value is used in
14525          pop_cp_function_context and then reset via pop_function_context.  */
14526       current_function_decl = NULL_TREE;
14527       /* We don't really care about obstacks, but the middle-end
14528          sometimes cares on what obstck things are located.  */
14529       permanent_allocation (1);
14530     }
14531
14532   return fndecl;
14533 }
14534 \f
14535 /* Create the FUNCTION_DECL for a function definition.
14536    DECLSPECS and DECLARATOR are the parts of the declaration;
14537    they describe the return type and the name of the function,
14538    but twisted together in a fashion that parallels the syntax of C.
14539
14540    This function creates a binding context for the function body
14541    as well as setting up the FUNCTION_DECL in current_function_decl.
14542
14543    Returns a FUNCTION_DECL on success.
14544
14545    If the DECLARATOR is not suitable for a function (it defines a datum
14546    instead), we return 0, which tells yyparse to report a parse error.
14547
14548    May return void_type_node indicating that this method is actually
14549    a friend.  See grokfield for more details.
14550
14551    Came here with a `.pushlevel' .
14552
14553    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14554    CHANGES TO CODE IN `grokfield'.  */
14555
14556 tree
14557 start_method (declspecs, declarator, attrlist)
14558      tree declarator, declspecs, attrlist;
14559 {
14560   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14561                                 attrlist);
14562
14563   /* Something too ugly to handle.  */
14564   if (fndecl == NULL_TREE)
14565     return NULL_TREE;
14566
14567   /* Pass friends other than inline friend functions back.  */
14568   if (fndecl == void_type_node)
14569     return fndecl;
14570
14571   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14572     /* Not a function, tell parser to report parse error.  */
14573     return NULL_TREE;
14574
14575   if (DECL_IN_AGGR_P (fndecl))
14576     {
14577       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14578         {
14579           if (DECL_CONTEXT (fndecl)
14580               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14581             cp_error ("`%D' is already defined in class %s", fndecl,
14582                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14583         }
14584       return void_type_node;
14585     }
14586
14587   check_template_shadow (fndecl);
14588
14589   DECL_THIS_INLINE (fndecl) = 1;
14590
14591   if (flag_default_inline)
14592     DECL_INLINE (fndecl) = 1;
14593
14594   /* We process method specializations in finish_struct_1.  */
14595   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14596     fndecl = push_template_decl (fndecl);
14597
14598   if (! DECL_FRIEND_P (fndecl))
14599     {
14600       if (TREE_CHAIN (fndecl))
14601         {
14602           fndecl = copy_node (fndecl);
14603           TREE_CHAIN (fndecl) = NULL_TREE;
14604         }
14605
14606       if (DECL_CONSTRUCTOR_P (fndecl))
14607         {
14608           if (! grok_ctor_properties (current_class_type, fndecl))
14609             return void_type_node;
14610         }
14611       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14612         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14613     }
14614
14615   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14616
14617   /* Make a place for the parms */
14618   pushlevel (0);
14619   current_binding_level->parm_flag = 1;
14620
14621   DECL_IN_AGGR_P (fndecl) = 1;
14622   return fndecl;
14623 }
14624
14625 /* Go through the motions of finishing a function definition.
14626    We don't compile this method until after the whole class has
14627    been processed.
14628
14629    FINISH_METHOD must return something that looks as though it
14630    came from GROKFIELD (since we are defining a method, after all).
14631
14632    This is called after parsing the body of the function definition.
14633    STMTS is the chain of statements that makes up the function body.
14634
14635    DECL is the ..._DECL that `start_method' provided.  */
14636
14637 tree
14638 finish_method (decl)
14639      tree decl;
14640 {
14641   register tree fndecl = decl;
14642   tree old_initial;
14643
14644   register tree link;
14645
14646   if (decl == void_type_node)
14647     return decl;
14648
14649   old_initial = DECL_INITIAL (fndecl);
14650
14651   /* Undo the level for the parms (from start_method).
14652      This is like poplevel, but it causes nothing to be
14653      saved.  Saving information here confuses symbol-table
14654      output routines.  Besides, this information will
14655      be correctly output when this method is actually
14656      compiled.  */
14657
14658   /* Clear out the meanings of the local variables of this level;
14659      also record in each decl which block it belongs to.  */
14660
14661   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14662     {
14663       if (DECL_NAME (link) != NULL_TREE)
14664         pop_binding (DECL_NAME (link), link);
14665       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14666       DECL_CONTEXT (link) = NULL_TREE;
14667     }
14668
14669   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14670                       (HOST_WIDE_INT) current_binding_level->level_chain,
14671                       current_binding_level->parm_flag,
14672                       current_binding_level->keep);
14673
14674   poplevel (0, 0, 0);
14675
14676   DECL_INITIAL (fndecl) = old_initial;
14677
14678   /* We used to check if the context of FNDECL was different from
14679      current_class_type as another way to get inside here.  This didn't work
14680      for String.cc in libg++.  */
14681   if (DECL_FRIEND_P (fndecl))
14682     {
14683       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14684         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14685       decl = void_type_node;
14686     }
14687
14688   return decl;
14689 }
14690 \f
14691 /* Called when a new struct TYPE is defined.
14692    If this structure or union completes the type of any previous
14693    variable declaration, lay it out and output its rtl.  */
14694
14695 void
14696 hack_incomplete_structures (type)
14697      tree type;
14698 {
14699   tree *list;
14700   struct binding_level *level;
14701
14702   if (!type) /* Don't do this for class templates.  */
14703     return;
14704
14705   if (namespace_bindings_p ())
14706     {
14707       level = 0;
14708       list = &namespace_scope_incomplete;
14709     }
14710   else
14711     {
14712       level = innermost_nonclass_level ();
14713       list = &level->incomplete;
14714     }
14715
14716   while (1)
14717     {
14718       while (*list)
14719         {
14720           tree decl = TREE_VALUE (*list);
14721           if ((decl && TREE_TYPE (decl) == type)
14722               || (TREE_TYPE (decl)
14723                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14724                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14725             {
14726               int toplevel = toplevel_bindings_p ();
14727               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14728                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14729                 layout_type (TREE_TYPE (decl));
14730               layout_decl (decl, 0);
14731               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14732               if (! toplevel)
14733                 {
14734                   tree cleanup;
14735                   expand_decl (decl);
14736                   cleanup = maybe_build_cleanup (decl);
14737                   expand_decl_init (decl);
14738                   if (! expand_decl_cleanup (decl, cleanup))
14739                     cp_error ("parser lost in parsing declaration of `%D'",
14740                               decl);
14741                 }
14742               *list = TREE_CHAIN (*list);
14743             }
14744           else
14745             list = &TREE_CHAIN (*list);
14746         }
14747
14748       /* Keep looking through artificial binding levels generated
14749          for local variables.  */
14750       if (level && level->keep == 2)
14751         {
14752           level = level->level_chain;
14753           list = &level->incomplete;
14754         }
14755       else
14756         break;
14757     }
14758 }
14759
14760 /* If DECL is of a type which needs a cleanup, build that cleanup
14761    here.  */
14762
14763 tree
14764 maybe_build_cleanup (decl)
14765      tree decl;
14766 {
14767   tree type = TREE_TYPE (decl);
14768
14769   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14770     {
14771       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14772       tree rval;
14773
14774       if (TREE_CODE (type) == ARRAY_TYPE)
14775         rval = decl;
14776       else
14777         {
14778           mark_addressable (decl);
14779           rval = build_unary_op (ADDR_EXPR, decl, 0);
14780         }
14781
14782       /* Optimize for space over speed here.  */
14783       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14784           || flag_expensive_optimizations)
14785         flags |= LOOKUP_NONVIRTUAL;
14786
14787       rval = build_delete (TREE_TYPE (rval), rval,
14788                            sfk_complete_destructor, flags, 0);
14789
14790       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14791           && ! TYPE_HAS_DESTRUCTOR (type))
14792         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14793                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14794
14795       return rval;
14796     }
14797   return 0;
14798 }
14799 \f
14800 /* Expand a C++ expression at the statement level.
14801    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14802    The C++ type checker should get all of these out when
14803    expressions are combined with other, type-providing, expressions,
14804    leaving only orphan expressions, such as:
14805
14806    &class::bar;         / / takes its address, but does nothing with it.  */
14807
14808 void
14809 cplus_expand_expr_stmt (exp)
14810      tree exp;
14811 {
14812 #if 0
14813   /* We should do this eventually, but right now this causes regex.o from
14814      libg++ to miscompile, and tString to core dump.  */
14815   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14816 #endif
14817
14818   /* If we don't do this, we end up down inside expand_expr
14819      trying to do TYPE_MODE on the ERROR_MARK, and really
14820      go outside the bounds of the type.  */
14821   if (exp != error_mark_node)
14822     expand_expr_stmt (exp);
14823 }
14824
14825 /* When a stmt has been parsed, this function is called.  */
14826
14827 void
14828 finish_stmt ()
14829 {
14830   /* Always assume this statement was not an expression statement.  If
14831      it actually was an expression statement, its our callers
14832      responsibility to fix this up.  */
14833   last_expr_type = NULL_TREE;
14834 }
14835
14836 /* DECL was originally constructed as a non-static member function,
14837    but turned out to be static.  Update it accordingly.  */
14838
14839 void
14840 revert_static_member_fn (decl)
14841      tree decl;
14842 {
14843   tree tmp;
14844   tree function = TREE_TYPE (decl);
14845   tree args = TYPE_ARG_TYPES (function);
14846
14847   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14848       != TYPE_UNQUALIFIED)
14849     cp_error ("static member function `%#D' declared with type qualifiers",
14850               *decl);
14851
14852   args = TREE_CHAIN (args);
14853   tmp = build_function_type (TREE_TYPE (function), args);
14854   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14855   tmp = build_exception_variant (tmp,
14856                                  TYPE_RAISES_EXCEPTIONS (function));
14857   TREE_TYPE (decl) = tmp;
14858   if (DECL_ARGUMENTS (decl))
14859     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14860   DECL_STATIC_FUNCTION_P (decl) = 1;
14861 }
14862
14863 /* Initialize the variables used during compilation of a C++
14864    function.  */
14865
14866 static void
14867 push_cp_function_context (f)
14868      struct function *f;
14869 {
14870   struct language_function *p
14871     = ((struct language_function *)
14872        xcalloc (1, sizeof (struct language_function)));
14873   f->language = p;
14874
14875   /* It takes an explicit call to expand_body to generate RTL for a
14876      function.  */
14877   expanding_p = 0;
14878
14879   /* Whenever we start a new function, we destroy temporaries in the
14880      usual way.  */
14881   current_stmt_tree->stmts_are_full_exprs_p = 1;
14882 }
14883
14884 /* Free the language-specific parts of F, now that we've finished
14885    compiling the function.  */
14886
14887 static void
14888 pop_cp_function_context (f)
14889      struct function *f;
14890 {
14891   if (f->language)
14892     free (f->language);
14893   f->language = 0;
14894 }
14895
14896 /* Mark P for GC.  */
14897
14898 static void
14899 mark_lang_function (p)
14900      struct language_function *p;
14901 {
14902   if (!p)
14903     return;
14904
14905   ggc_mark_tree (p->x_ctor_label);
14906   ggc_mark_tree (p->x_dtor_label);
14907   ggc_mark_tree (p->x_current_class_ptr);
14908   ggc_mark_tree (p->x_current_class_ref);
14909   ggc_mark_tree (p->x_eh_spec_try_block);
14910   ggc_mark_tree (p->x_scope_stmt_stack);
14911
14912   ggc_mark_rtx (p->x_result_rtx);
14913
14914   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14915   mark_stmt_tree (&p->x_stmt_tree);
14916   mark_binding_level (&p->bindings);
14917 }
14918
14919 /* Mark the language-specific data in F for GC.  */
14920
14921 static void
14922 mark_cp_function_context (f)
14923      struct function *f;
14924 {
14925   mark_lang_function (f->language);
14926 }
14927
14928 void
14929 lang_mark_false_label_stack (l)
14930      struct label_node *l;
14931 {
14932   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14933   my_friendly_assert (l == NULL, 19990904);
14934 }
14935
14936 void
14937 lang_mark_tree (t)
14938      tree t;
14939 {
14940   enum tree_code code = TREE_CODE (t);
14941   if (code == IDENTIFIER_NODE)
14942     {
14943       struct lang_identifier *li = (struct lang_identifier *) t;
14944       struct lang_id2 *li2 = li->x;
14945       ggc_mark_tree (li->namespace_bindings);
14946       ggc_mark_tree (li->bindings);
14947       ggc_mark_tree (li->class_value);
14948       ggc_mark_tree (li->class_template_info);
14949
14950       if (li2)
14951         {
14952           ggc_mark_tree (li2->label_value);
14953           ggc_mark_tree (li2->implicit_decl);
14954           ggc_mark_tree (li2->error_locus);
14955         }
14956     }
14957   else if (code == CPLUS_BINDING)
14958     {
14959       if (BINDING_HAS_LEVEL_P (t))
14960         mark_binding_level (&BINDING_LEVEL (t));
14961       else
14962         ggc_mark_tree (BINDING_SCOPE (t));
14963       ggc_mark_tree (BINDING_VALUE (t));
14964     }
14965   else if (code == OVERLOAD)
14966     ggc_mark_tree (OVL_FUNCTION (t));
14967   else if (code == TEMPLATE_PARM_INDEX)
14968     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14969   else if (TREE_CODE_CLASS (code) == 'd')
14970     {
14971       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14972
14973       if (ld)
14974         {
14975           ggc_mark (ld);
14976           if (!DECL_GLOBAL_CTOR_P (t)
14977               && !DECL_GLOBAL_DTOR_P (t)
14978               && !DECL_THUNK_P (t))
14979             ggc_mark_tree (ld->decl_flags.u2.access);
14980           else if (DECL_THUNK_P (t))
14981             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14982           ggc_mark_tree (ld->decl_flags.context);
14983           if (TREE_CODE (t) != NAMESPACE_DECL)
14984             ggc_mark_tree (ld->decl_flags.u.template_info);
14985           else
14986             mark_binding_level (&NAMESPACE_LEVEL (t));
14987           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14988             {
14989               ggc_mark_tree (ld->befriending_classes);
14990               ggc_mark_tree (ld->saved_tree);
14991               ggc_mark_tree (ld->cloned_function);
14992               if (!DECL_OVERLOADED_OPERATOR_P (t))
14993                 ggc_mark_tree (ld->u2.vtt_parm);
14994               if (TREE_CODE (t) == TYPE_DECL)
14995                 ggc_mark_tree (ld->u.sorted_fields);
14996               else if (TREE_CODE (t) == FUNCTION_DECL
14997                        && !DECL_PENDING_INLINE_P (t))
14998                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14999             }
15000         }
15001     }
15002   else if (TREE_CODE_CLASS (code) == 't')
15003     {
15004       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
15005
15006       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15007                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15008         {
15009           ggc_mark (lt);
15010           ggc_mark_tree (lt->vfields);
15011           ggc_mark_tree (lt->vbases);
15012           ggc_mark_tree (lt->tags);
15013           ggc_mark_tree (lt->size);
15014           ggc_mark_tree (lt->pure_virtuals);
15015           ggc_mark_tree (lt->friend_classes);
15016           ggc_mark_tree (lt->rtti);
15017           ggc_mark_tree (lt->methods);
15018           ggc_mark_tree (lt->template_info);
15019           ggc_mark_tree (lt->befriending_classes);
15020         }
15021       else if (lt)
15022         /* In the case of pointer-to-member function types, the
15023            TYPE_LANG_SPECIFIC is really just a tree.  */
15024         ggc_mark_tree ((tree) lt);
15025     }
15026 }