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 (TREE_CODE (newdecl) == VAR_DECL)
3530         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3531       /* Do this after calling `common_type' so that default
3532          parameters don't confuse us.  */
3533       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3534           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3535               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3536         {
3537           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3538                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3539           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3540                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3541
3542           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3543               && DECL_SOURCE_LINE (olddecl) != 0
3544               && flag_exceptions
3545               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3546                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3547             {
3548               cp_error ("declaration of `%F' throws different exceptions",
3549                         newdecl);
3550               cp_error_at ("than previous declaration `%F'", olddecl);
3551             }
3552         }
3553       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3554
3555       /* Lay the type out, unless already done.  */
3556       if (! same_type_p (newtype, oldtype)
3557           && TREE_TYPE (newdecl) != error_mark_node
3558           && !(processing_template_decl && uses_template_parms (newdecl)))
3559         layout_type (TREE_TYPE (newdecl));
3560
3561       if ((TREE_CODE (newdecl) == VAR_DECL
3562            || TREE_CODE (newdecl) == PARM_DECL
3563            || TREE_CODE (newdecl) == RESULT_DECL
3564            || TREE_CODE (newdecl) == FIELD_DECL
3565            || TREE_CODE (newdecl) == TYPE_DECL)
3566           && !(processing_template_decl && uses_template_parms (newdecl)))
3567         layout_decl (newdecl, 0);
3568
3569       /* Merge the type qualifiers.  */
3570       if (TREE_READONLY (newdecl))
3571         TREE_READONLY (olddecl) = 1;
3572       if (TREE_THIS_VOLATILE (newdecl))
3573         TREE_THIS_VOLATILE (olddecl) = 1;
3574
3575       /* Merge the initialization information.  */
3576       if (DECL_INITIAL (newdecl) == NULL_TREE
3577           && DECL_INITIAL (olddecl) != NULL_TREE)
3578         {
3579           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3580           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3581           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3582           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3583               && DECL_LANG_SPECIFIC (newdecl)
3584               && DECL_LANG_SPECIFIC (olddecl))
3585             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3586         }
3587
3588       /* Merge the section attribute.
3589          We want to issue an error if the sections conflict but that must be
3590          done later in decl_attributes since we are called before attributes
3591          are assigned.  */
3592       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3593         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3594
3595       /* Keep the old rtl since we can safely use it.  */
3596       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3597
3598       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3599         {
3600           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3601             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3602           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3603             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3604           DECL_NO_LIMIT_STACK (newdecl)
3605             |= DECL_NO_LIMIT_STACK (olddecl);
3606         }
3607     }
3608   /* If cannot merge, then use the new type and qualifiers,
3609      and don't preserve the old rtl.  */
3610   else
3611     {
3612       /* Clean out any memory we had of the old declaration.  */
3613       tree oldstatic = value_member (olddecl, static_aggregates);
3614       if (oldstatic)
3615         TREE_VALUE (oldstatic) = error_mark_node;
3616
3617       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3618       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3619       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3620       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3621     }
3622
3623   /* Merge the storage class information.  */
3624   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3625   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3626   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3627   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3628   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3629   if (! DECL_EXTERNAL (olddecl))
3630     DECL_EXTERNAL (newdecl) = 0;
3631
3632   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3633     {
3634       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3635       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3636       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3637       DECL_TEMPLATE_INSTANTIATED (newdecl)
3638         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3639       /* Don't really know how much of the language-specific
3640          values we should copy from old to new.  */
3641       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3642       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3643       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3644       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3645       olddecl_friend = DECL_FRIEND_P (olddecl);
3646
3647       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3648       if (TREE_CODE (newdecl) == FUNCTION_DECL
3649           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3650         DECL_BEFRIENDING_CLASSES (newdecl)
3651           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3652                      DECL_BEFRIENDING_CLASSES (olddecl));
3653     }
3654
3655   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3656     {
3657       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3658           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3659         {
3660           /* If newdecl is not a specialization, then it is not a
3661              template-related function at all.  And that means that we
3662              shoud have exited above, returning 0.  */
3663           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3664                               0);
3665
3666           if (TREE_USED (olddecl))
3667             /* From [temp.expl.spec]:
3668
3669                If a template, a member template or the member of a class
3670                template is explicitly specialized then that
3671                specialization shall be declared before the first use of
3672                that specialization that would cause an implicit
3673                instantiation to take place, in every translation unit in
3674                which such a use occurs.  */
3675             cp_error ("explicit specialization of %D after first use",
3676                       olddecl);
3677
3678           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3679         }
3680       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3681
3682       /* If either decl says `inline', this fn is inline, unless its
3683          definition was passed already.  */
3684       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3685         DECL_INLINE (olddecl) = 1;
3686       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3687
3688       if (! types_match)
3689         {
3690           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3691           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3692           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3693         }
3694       if (! types_match || new_defines_function)
3695         {
3696           /* These need to be copied so that the names are available.
3697              Note that if the types do match, we'll preserve inline
3698              info and other bits, but if not, we won't.  */
3699           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3700           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3701         }
3702       if (new_defines_function)
3703         /* If defining a function declared with other language
3704            linkage, use the previously declared language linkage.  */
3705         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3706       else if (types_match)
3707         {
3708           /* If redeclaring a builtin function, and not a definition,
3709              it stays built in.  */
3710           if (DECL_BUILT_IN (olddecl))
3711             {
3712               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3713               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3714               /* If we're keeping the built-in definition, keep the rtl,
3715                  regardless of declaration matches.  */
3716               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3717             }
3718           else
3719             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3720
3721           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3722           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3723             /* Previously saved insns go together with
3724                the function's previous definition.  */
3725             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3726           /* Don't clear out the arguments if we're redefining a function.  */
3727           if (DECL_ARGUMENTS (olddecl))
3728             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3729         }
3730     }
3731
3732   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3733     {
3734       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3735     }
3736
3737   /* Now preserve various other info from the definition.  */
3738   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3739   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3740   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3741   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3742
3743   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3744     {
3745       int function_size;
3746
3747       function_size = sizeof (struct tree_decl);
3748
3749       bcopy ((char *) newdecl + sizeof (struct tree_common),
3750              (char *) olddecl + sizeof (struct tree_common),
3751              function_size - sizeof (struct tree_common));
3752
3753       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3754         {
3755           /* If newdecl is a template instantiation, it is possible that
3756              the following sequence of events has occurred:
3757
3758              o A friend function was declared in a class template.  The
3759              class template was instantiated.
3760
3761              o The instantiation of the friend declaration was
3762              recorded on the instantiation list, and is newdecl.
3763
3764              o Later, however, instantiate_class_template called pushdecl
3765              on the newdecl to perform name injection.  But, pushdecl in
3766              turn called duplicate_decls when it discovered that another
3767              declaration of a global function with the same name already
3768              existed.
3769
3770              o Here, in duplicate_decls, we decided to clobber newdecl.
3771
3772              If we're going to do that, we'd better make sure that
3773              olddecl, and not newdecl, is on the list of
3774              instantiations so that if we try to do the instantiation
3775              again we won't get the clobbered declaration.  */
3776
3777           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3778           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3779
3780           for (; decls; decls = TREE_CHAIN (decls))
3781             if (TREE_VALUE (decls) == newdecl)
3782               TREE_VALUE (decls) = olddecl;
3783         }
3784     }
3785   else
3786     {
3787       bcopy ((char *) newdecl + sizeof (struct tree_common),
3788              (char *) olddecl + sizeof (struct tree_common),
3789              sizeof (struct tree_decl) - sizeof (struct tree_common)
3790              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3791     }
3792
3793   DECL_UID (olddecl) = olddecl_uid;
3794   if (olddecl_friend)
3795     DECL_FRIEND_P (olddecl) = 1;
3796
3797   /* NEWDECL contains the merged attribute lists.
3798      Update OLDDECL to be the same.  */
3799   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3800
3801   return 1;
3802 }
3803
3804 /* Record a decl-node X as belonging to the current lexical scope.
3805    Check for errors (such as an incompatible declaration for the same
3806    name already seen in the same scope).
3807
3808    Returns either X or an old decl for the same name.
3809    If an old decl is returned, it may have been smashed
3810    to agree with what X says.  */
3811
3812 tree
3813 pushdecl (x)
3814      tree x;
3815 {
3816   register tree t;
3817   register tree name;
3818   int need_new_binding;
3819
3820   /* We shouldn't be calling pushdecl when we're generating RTL for a
3821      function that we already did semantic analysis on previously.  */
3822   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3823                       19990913);
3824
3825   need_new_binding = 1;
3826
3827   if (DECL_TEMPLATE_PARM_P (x))
3828     /* Template parameters have no context; they are not X::T even
3829        when declared within a class or namespace.  */
3830     ;
3831   else
3832     {
3833       if (current_function_decl && x != current_function_decl
3834           /* A local declaration for a function doesn't constitute
3835              nesting.  */
3836           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3837           /* A local declaration for an `extern' variable is in the
3838              scoped of the current namespace, not the current
3839              function.  */
3840           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3841           && !DECL_CONTEXT (x))
3842         DECL_CONTEXT (x) = current_function_decl;
3843
3844       /* If this is the declaration for a namespace-scope function,
3845          but the declaration itself is in a local scope, mark the
3846          declaration.  */
3847       if (TREE_CODE (x) == FUNCTION_DECL
3848           && DECL_NAMESPACE_SCOPE_P (x)
3849           && current_function_decl
3850           && x != current_function_decl)
3851         DECL_LOCAL_FUNCTION_P (x) = 1;
3852     }
3853
3854   name = DECL_NAME (x);
3855   if (name)
3856     {
3857 #if 0
3858       /* Not needed...see below.  */
3859       char *file;
3860       int line;
3861 #endif
3862       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3863         name = TREE_OPERAND (name, 0);
3864
3865       /* Namespace-scoped variables are not found in the current level. */
3866       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3867         t = namespace_binding (name, DECL_CONTEXT (x));
3868       else
3869         t = lookup_name_current_level (name);
3870
3871       /* If we are declaring a function, and the result of name-lookup
3872          was an OVERLOAD, look for an overloaded instance that is
3873          actually the same as the function we are declaring.  (If
3874          there is one, we have to merge our declaration with the
3875          previous declaration.)  */
3876       if (t && TREE_CODE (t) == OVERLOAD)
3877         {
3878           tree match;
3879
3880           if (TREE_CODE (x) == FUNCTION_DECL)
3881             for (match = t; match; match = OVL_NEXT (match))
3882               {
3883                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3884                     == DECL_ASSEMBLER_NAME (x))
3885                   break;
3886               }
3887           else
3888             /* Just choose one.  */
3889             match = t;
3890
3891           if (match)
3892             t = OVL_CURRENT (match);
3893           else
3894             t = NULL_TREE;
3895         }
3896
3897       if (t == error_mark_node)
3898         {
3899           /* error_mark_node is 0 for a while during initialization!  */
3900           t = NULL_TREE;
3901           cp_error_at ("`%#D' used prior to declaration", x);
3902         }
3903       else if (t != NULL_TREE)
3904         {
3905           if (TREE_CODE (t) == PARM_DECL)
3906             {
3907               if (DECL_CONTEXT (t) == NULL_TREE)
3908                 fatal ("parse errors have confused me too much");
3909
3910               /* Check for duplicate params.  */
3911               if (duplicate_decls (x, t))
3912                 return t;
3913             }
3914           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3915                     || DECL_FUNCTION_TEMPLATE_P (x))
3916                    && is_overloaded_fn (t))
3917             /* Don't do anything just yet. */;
3918           else if (t == wchar_decl_node)
3919             {
3920               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3921                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3922
3923               /* Throw away the redeclaration.  */
3924               return t;
3925             }
3926           else if (TREE_CODE (t) != TREE_CODE (x))
3927             {
3928               if (duplicate_decls (x, t))
3929                 return t;
3930             }
3931           else if (duplicate_decls (x, t))
3932             {
3933               if (TREE_CODE (t) == TYPE_DECL)
3934                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3935               else if (TREE_CODE (t) == FUNCTION_DECL)
3936                 check_default_args (t);
3937
3938               return t;
3939             }
3940           else if (DECL_MAIN_P (x))
3941             {
3942               /* A redeclaration of main, but not a duplicate of the
3943                  previous one.
3944
3945                  [basic.start.main]
3946
3947                  This function shall not be overloaded.  */
3948               cp_error_at ("invalid redeclaration of `%D'", t);
3949               cp_error ("as `%D'", x);
3950               /* We don't try to push this declaration since that
3951                  causes a crash.  */
3952               return x;
3953             }
3954         }
3955
3956       check_template_shadow (x);
3957
3958       /* If this is a function conjured up by the backend, massage it
3959          so it looks friendly.  */
3960       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3961         {
3962           retrofit_lang_decl (x);
3963           DECL_LANGUAGE (x) = lang_c;
3964         }
3965
3966       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3967         {
3968           t = push_overloaded_decl (x, PUSH_LOCAL);
3969           if (t != x)
3970             return t;
3971           if (!namespace_bindings_p ())
3972             /* We do not need to create a binding for this name;
3973                push_overloaded_decl will have already done so if
3974                necessary.  */
3975             need_new_binding = 0;
3976         }
3977       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3978         {
3979           t = push_overloaded_decl (x, PUSH_GLOBAL);
3980           if (t == x)
3981             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3982           return t;
3983         }
3984
3985       /* If declaring a type as a typedef, copy the type (unless we're
3986          at line 0), and install this TYPE_DECL as the new type's typedef
3987          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3988       if (TREE_CODE (x) == TYPE_DECL)
3989         {
3990           tree type = TREE_TYPE (x);
3991           if (DECL_SOURCE_LINE (x) == 0)
3992             {
3993               if (TYPE_NAME (type) == 0)
3994                 TYPE_NAME (type) = x;
3995             }
3996           else if (type != error_mark_node && TYPE_NAME (type) != x
3997                    /* We don't want to copy the type when all we're
3998                       doing is making a TYPE_DECL for the purposes of
3999                       inlining.  */
4000                    && (!TYPE_NAME (type)
4001                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4002             {
4003               DECL_ORIGINAL_TYPE (x) = type;
4004               type = build_type_copy (type);
4005               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4006               TYPE_NAME (type) = x;
4007               TREE_TYPE (x) = type;
4008             }
4009
4010           if (type != error_mark_node
4011               && TYPE_NAME (type)
4012               && TYPE_IDENTIFIER (type))
4013             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4014                                                   current_binding_level);
4015
4016         }
4017
4018       /* Multiple external decls of the same identifier ought to match.
4019
4020          We get warnings about inline functions where they are defined.
4021          We get warnings about other functions from push_overloaded_decl.
4022
4023          Avoid duplicate warnings where they are used.  */
4024       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4025         {
4026           tree decl;
4027
4028           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4029           if (decl && TREE_CODE (decl) == OVERLOAD)
4030             decl = OVL_FUNCTION (decl);
4031
4032           if (decl && decl != error_mark_node
4033               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4034               /* If different sort of thing, we already gave an error.  */
4035               && TREE_CODE (decl) == TREE_CODE (x)
4036               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4037             {
4038               cp_pedwarn ("type mismatch with previous external decl", x);
4039               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4040             }
4041         }
4042
4043       /* This name is new in its binding level.
4044          Install the new declaration and return it.  */
4045       if (namespace_bindings_p ())
4046         {
4047           /* Install a global value.  */
4048
4049           /* If the first global decl has external linkage,
4050              warn if we later see static one.  */
4051           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4052             TREE_PUBLIC (name) = 1;
4053
4054           /* Bind the mangled name for the entity.  In the future, we
4055              should not need to do this; mangled names are an
4056              implementation detail of which the front-end should not
4057              need to be aware.  */
4058           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4059                 && t != NULL_TREE)
4060               /* For an ordinary function, we create a binding from
4061                  the mangled name (i.e., NAME) to the DECL.  But, for
4062                  an `extern "C"' function, the mangled name and the
4063                  ordinary name are the same so we need not do this.  */
4064               && !DECL_EXTERN_C_FUNCTION_P (x))
4065             {
4066               tree mangled_name;
4067
4068               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4069                   || TREE_CODE (x) == NAMESPACE_DECL)
4070                 mangled_name = name;
4071               else
4072                 mangled_name = DECL_ASSEMBLER_NAME (x);
4073
4074               if (TREE_CODE (x) == FUNCTION_DECL)
4075                 my_friendly_assert
4076                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4077                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4078               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4079             }
4080
4081           /* Don't forget if the function was used via an implicit decl.  */
4082           if (IDENTIFIER_IMPLICIT_DECL (name)
4083               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4084             TREE_USED (x) = 1;
4085
4086           /* Don't forget if its address was taken in that way.  */
4087           if (IDENTIFIER_IMPLICIT_DECL (name)
4088               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4089             TREE_ADDRESSABLE (x) = 1;
4090
4091           /* Warn about mismatches against previous implicit decl.  */
4092           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4093               /* If this real decl matches the implicit, don't complain.  */
4094               && ! (TREE_CODE (x) == FUNCTION_DECL
4095                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4096             cp_warning
4097               ("`%D' was previously implicitly declared to return `int'", x);
4098
4099           /* If new decl is `static' and an `extern' was seen previously,
4100              warn about it.  */
4101           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4102             warn_extern_redeclared_static (x, t);
4103         }
4104       else
4105         {
4106           /* Here to install a non-global value.  */
4107           tree oldlocal = IDENTIFIER_VALUE (name);
4108           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4109
4110           if (need_new_binding)
4111             {
4112               push_local_binding (name, x, 0);
4113               /* Because push_local_binding will hook X on to the
4114                  current_binding_level's name list, we don't want to
4115                  do that again below.  */
4116               need_new_binding = 0;
4117             }
4118
4119           /* If this is a TYPE_DECL, push it into the type value slot.  */
4120           if (TREE_CODE (x) == TYPE_DECL)
4121             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4122                                                   current_binding_level);
4123
4124           /* Clear out any TYPE_DECL shadowed by a namespace so that
4125              we won't think this is a type.  The C struct hack doesn't
4126              go through namespaces.  */
4127           if (TREE_CODE (x) == NAMESPACE_DECL)
4128             set_identifier_type_value_with_scope (name, NULL_TREE,
4129                                                   current_binding_level);
4130
4131           if (oldlocal)
4132             {
4133               tree d = oldlocal;
4134
4135               while (oldlocal
4136                      && TREE_CODE (oldlocal) == VAR_DECL
4137                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4138                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4139
4140               if (oldlocal == NULL_TREE)
4141                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4142             }
4143
4144           /* If this is an extern function declaration, see if we
4145              have a global definition or declaration for the function.  */
4146           if (oldlocal == NULL_TREE
4147               && DECL_EXTERNAL (x)
4148               && oldglobal != NULL_TREE
4149               && TREE_CODE (x) == FUNCTION_DECL
4150               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4151             {
4152               /* We have one.  Their types must agree.  */
4153               if (decls_match (x, oldglobal))
4154                 /* OK */;
4155               else
4156                 {
4157                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4158                   cp_warning_at ("global declaration `%#D'", oldglobal);
4159                 }
4160             }
4161           /* If we have a local external declaration,
4162              and no file-scope declaration has yet been seen,
4163              then if we later have a file-scope decl it must not be static.  */
4164           if (oldlocal == NULL_TREE
4165               && oldglobal == NULL_TREE
4166               && DECL_EXTERNAL (x)
4167               && TREE_PUBLIC (x))
4168             TREE_PUBLIC (name) = 1;
4169
4170           /* Warn if shadowing an argument at the top level of the body.  */
4171           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4172               /* Inline decls shadow nothing.  */
4173               && !DECL_FROM_INLINE (x)
4174               && TREE_CODE (oldlocal) == PARM_DECL
4175               /* Don't complain if it's from an enclosing function.  */
4176               && DECL_CONTEXT (oldlocal) == current_function_decl
4177               && TREE_CODE (x) != PARM_DECL)
4178             {
4179               /* Go to where the parms should be and see if we
4180                  find them there.  */
4181               struct binding_level *b = current_binding_level->level_chain;
4182
4183               if (cleanup_label)
4184                 b = b->level_chain;
4185
4186               /* ARM $8.3 */
4187               if (b->parm_flag == 1)
4188                 cp_error ("declaration of `%#D' shadows a parameter", name);
4189             }
4190
4191           /* Maybe warn if shadowing something else.  */
4192           if (warn_shadow && !DECL_EXTERNAL (x)
4193               /* Inline decls shadow nothing.  */
4194               && !DECL_FROM_INLINE (x)
4195               /* No shadow warnings for internally generated vars.  */
4196               && ! DECL_ARTIFICIAL (x)
4197               /* No shadow warnings for vars made for inlining.  */
4198               && ! DECL_FROM_INLINE (x))
4199             {
4200               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4201                 warning ("declaration of `%s' shadows a parameter",
4202                         IDENTIFIER_POINTER (name));
4203               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4204                        && current_class_ptr
4205                        && !TREE_STATIC (name))
4206                 warning ("declaration of `%s' shadows a member of `this'",
4207                         IDENTIFIER_POINTER (name));
4208               else if (oldlocal != NULL_TREE)
4209                 warning ("declaration of `%s' shadows previous local",
4210                         IDENTIFIER_POINTER (name));
4211               else if (oldglobal != NULL_TREE)
4212                 /* XXX shadow warnings in outer-more namespaces */
4213                 warning ("declaration of `%s' shadows global declaration",
4214                         IDENTIFIER_POINTER (name));
4215             }
4216         }
4217
4218       if (TREE_CODE (x) == FUNCTION_DECL)
4219         check_default_args (x);
4220
4221       /* Keep count of variables in this level with incomplete type.  */
4222       if (TREE_CODE (x) == VAR_DECL
4223           && TREE_TYPE (x) != error_mark_node
4224           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4225                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4226               /* RTTI TD entries are created while defining the type_info.  */
4227               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4228                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4229         {
4230           if (namespace_bindings_p ())
4231             namespace_scope_incomplete
4232               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4233           else
4234             current_binding_level->incomplete
4235               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4236         }
4237     }
4238
4239   if (need_new_binding)
4240     add_decl_to_level (x,
4241                        DECL_NAMESPACE_SCOPE_P (x)
4242                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4243                        : current_binding_level);
4244
4245   return x;
4246 }
4247
4248 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4249    caller to set DECL_CONTEXT properly.  */
4250
4251 static tree
4252 pushdecl_with_scope (x, level)
4253      tree x;
4254      struct binding_level *level;
4255 {
4256   register struct binding_level *b;
4257   tree function_decl = current_function_decl;
4258
4259   current_function_decl = NULL_TREE;
4260   if (level->parm_flag == 2)
4261     {
4262       b = class_binding_level;
4263       class_binding_level = level;
4264       pushdecl_class_level (x);
4265       class_binding_level = b;
4266     }
4267   else
4268     {
4269       b = current_binding_level;
4270       current_binding_level = level;
4271       x = pushdecl (x);
4272       current_binding_level = b;
4273     }
4274   current_function_decl = function_decl;
4275   return x;
4276 }
4277
4278 /* Like pushdecl, only it places X in the current namespace,
4279    if appropriate.  */
4280
4281 tree
4282 pushdecl_namespace_level (x)
4283      tree x;
4284 {
4285   register struct binding_level *b = current_binding_level;
4286   register tree t;
4287
4288   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4289
4290   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4291      what we want.  */
4292   if (TREE_CODE (x) == TYPE_DECL)
4293     {
4294       tree name = DECL_NAME (x);
4295       tree newval;
4296       tree *ptr = (tree *)0;
4297       for (; b != global_binding_level; b = b->level_chain)
4298         {
4299           tree shadowed = b->type_shadowed;
4300           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4301             if (TREE_PURPOSE (shadowed) == name)
4302               {
4303                 ptr = &TREE_VALUE (shadowed);
4304                 /* Can't break out of the loop here because sometimes
4305                    a binding level will have duplicate bindings for
4306                    PT names.  It's gross, but I haven't time to fix it.  */
4307               }
4308         }
4309       newval = TREE_TYPE (x);
4310       if (ptr == (tree *)0)
4311         {
4312           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4313              up here if this is changed to an assertion.  --KR  */
4314           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4315         }
4316       else
4317         {
4318           *ptr = newval;
4319         }
4320     }
4321   return t;
4322 }
4323
4324 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4325    if appropriate.  */
4326
4327 tree
4328 pushdecl_top_level (x)
4329      tree x;
4330 {
4331   push_to_top_level ();
4332   x = pushdecl_namespace_level (x);
4333   pop_from_top_level ();
4334   return x;
4335 }
4336
4337 /* Make the declaration of X appear in CLASS scope.  */
4338
4339 void
4340 pushdecl_class_level (x)
4341      tree x;
4342 {
4343   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4344      scope looks for the pre-mangled name.  */
4345   register tree name;
4346
4347   if (TREE_CODE (x) == OVERLOAD)
4348     x = OVL_CURRENT (x);
4349   name = DECL_NAME (x);
4350
4351   if (name)
4352     {
4353       push_class_level_binding (name, x);
4354       if (TREE_CODE (x) == TYPE_DECL)
4355         set_identifier_type_value (name, TREE_TYPE (x));
4356     }
4357   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4358     {
4359       tree f;
4360
4361       for (f = TYPE_FIELDS (TREE_TYPE (x));
4362            f;
4363            f = TREE_CHAIN (f))
4364         pushdecl_class_level (f);
4365     }
4366 }
4367
4368 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4369    DECL, or a modified version thereof.  */
4370
4371 tree
4372 maybe_push_decl (decl)
4373      tree decl;
4374 {
4375   tree type = TREE_TYPE (decl);
4376
4377   /* Add this decl to the current binding level, but not if it comes
4378      from another scope, e.g. a static member variable.  TEM may equal
4379      DECL or it may be a previous decl of the same name.  */
4380   if (decl == error_mark_node
4381       || (TREE_CODE (decl) != PARM_DECL
4382           && DECL_CONTEXT (decl) != NULL_TREE
4383           /* Definitions of namespace members outside their namespace are
4384              possible. */
4385           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4386       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4387       || TREE_CODE (type) == UNKNOWN_TYPE
4388       /* The declaration of a template specialization does not affect
4389          the functions available for overload resolution, so we do not
4390          call pushdecl.  */
4391       || (TREE_CODE (decl) == FUNCTION_DECL
4392           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4393     return decl;
4394   else
4395     return pushdecl (decl);
4396 }
4397
4398 /* Make the declaration(s) of X appear in CLASS scope
4399    under the name NAME.  */
4400
4401 void
4402 push_class_level_binding (name, x)
4403      tree name;
4404      tree x;
4405 {
4406   tree binding;
4407   /* The class_binding_level will be NULL if x is a template
4408      parameter name in a member template.  */
4409   if (!class_binding_level)
4410     return;
4411
4412   /* Make sure that this new member does not have the same name
4413      as a template parameter.  */
4414   if (TYPE_BEING_DEFINED (current_class_type))
4415     check_template_shadow (x);
4416
4417   /* If this declaration shadows a declaration from an enclosing
4418      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4419      we leave this class.  Record the shadowed declaration here.  */
4420   binding = IDENTIFIER_BINDING (name);
4421   if (binding
4422       && ((TREE_CODE (x) == OVERLOAD
4423            && BINDING_VALUE (binding)
4424            && is_overloaded_fn (BINDING_VALUE (binding)))
4425           || INHERITED_VALUE_BINDING_P (binding)))
4426     {
4427       tree shadow;
4428       tree old_decl;
4429
4430       /* If the old binding was from a base class, and was for a tag
4431          name, slide it over to make room for the new binding.  The
4432          old binding is still visible if explicitly qualified with a
4433          class-key.  */
4434       if (INHERITED_VALUE_BINDING_P (binding)
4435           && BINDING_VALUE (binding)
4436           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4437           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4438           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4439         {
4440           old_decl = BINDING_TYPE (binding);
4441           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4442           BINDING_VALUE (binding) = NULL_TREE;
4443           INHERITED_VALUE_BINDING_P (binding) = 0;
4444         }
4445       else
4446         old_decl = BINDING_VALUE (binding);
4447
4448       /* There was already a binding for X containing fewer
4449          functions than are named in X.  Find the previous
4450          declaration of X on the class-shadowed list, and update it.  */
4451       for (shadow = class_binding_level->class_shadowed;
4452            shadow;
4453            shadow = TREE_CHAIN (shadow))
4454         if (TREE_PURPOSE (shadow) == name
4455             && TREE_TYPE (shadow) == old_decl)
4456           {
4457             BINDING_VALUE (binding) = x;
4458             INHERITED_VALUE_BINDING_P (binding) = 0;
4459             TREE_TYPE (shadow) = x;
4460             return;
4461           }
4462     }
4463
4464   /* If we didn't replace an existing binding, put the binding on the
4465      stack of bindings for the identifier, and update
4466      IDENTIFIER_CLASS_VALUE.  */
4467   if (push_class_binding (name, x))
4468     {
4469       class_binding_level->class_shadowed
4470         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4471                      class_binding_level->class_shadowed);
4472       /* Record the value we are binding NAME to so that we can know
4473          what to pop later.  */
4474       TREE_TYPE (class_binding_level->class_shadowed) = x;
4475     }
4476 }
4477
4478 /* Insert another USING_DECL into the current binding level, returning
4479    this declaration. If this is a redeclaration, do nothing, and
4480    return NULL_TREE if this not in namespace scope (in namespace
4481    scope, a using decl might extend any previous bindings).  */
4482
4483 tree
4484 push_using_decl (scope, name)
4485      tree scope;
4486      tree name;
4487 {
4488   tree decl;
4489
4490   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4491   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4492   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4493     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4494       break;
4495   if (decl)
4496     return namespace_bindings_p () ? decl : NULL_TREE;
4497   decl = build_lang_decl (USING_DECL, name, void_type_node);
4498   DECL_INITIAL (decl) = scope;
4499   TREE_CHAIN (decl) = current_binding_level->usings;
4500   current_binding_level->usings = decl;
4501   return decl;
4502 }
4503
4504 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4505    changed (i.e. there was already a directive), or the fresh
4506    TREE_LIST otherwise.  */
4507
4508 tree
4509 push_using_directive (used)
4510      tree used;
4511 {
4512   tree ud = current_binding_level->using_directives;
4513   tree iter, ancestor;
4514
4515   /* Check if we already have this. */
4516   if (purpose_member (used, ud) != NULL_TREE)
4517     return NULL_TREE;
4518
4519   /* Recursively add all namespaces used. */
4520   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4521     push_using_directive (TREE_PURPOSE (iter));
4522
4523   ancestor = namespace_ancestor (current_decl_namespace (), used);
4524   ud = current_binding_level->using_directives;
4525   ud = tree_cons (used, ancestor, ud);
4526   current_binding_level->using_directives = ud;
4527   return ud;
4528 }
4529
4530 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4531    other definitions already in place.  We get around this by making
4532    the value of the identifier point to a list of all the things that
4533    want to be referenced by that name.  It is then up to the users of
4534    that name to decide what to do with that list.
4535
4536    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4537    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4538
4539    FLAGS is a bitwise-or of the following values:
4540      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4541                  namespace scope.
4542      PUSH_USING: DECL is being pushed as the result of a using
4543                  declaration.
4544
4545    The value returned may be a previous declaration if we guessed wrong
4546    about what language DECL should belong to (C or C++).  Otherwise,
4547    it's always DECL (and never something that's not a _DECL).  */
4548
4549 tree
4550 push_overloaded_decl (decl, flags)
4551      tree decl;
4552      int flags;
4553 {
4554   tree name = DECL_NAME (decl);
4555   tree old;
4556   tree new_binding;
4557   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4558
4559   if (doing_global)
4560     old = namespace_binding (name, DECL_CONTEXT (decl));
4561   else
4562     old = lookup_name_current_level (name);
4563
4564   if (old)
4565     {
4566       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4567         {
4568           tree t = TREE_TYPE (old);
4569           if (IS_AGGR_TYPE (t) && warn_shadow
4570               && (! DECL_IN_SYSTEM_HEADER (decl)
4571                   || ! DECL_IN_SYSTEM_HEADER (old)))
4572             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4573           old = NULL_TREE;
4574         }
4575       else if (is_overloaded_fn (old))
4576         {
4577           tree tmp;
4578
4579           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4580             {
4581               tree fn = OVL_CURRENT (tmp);
4582
4583               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4584                   && !(flags & PUSH_USING)
4585                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4586                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4587                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4588                           decl, fn);
4589
4590               if (duplicate_decls (decl, fn))
4591                 return fn;
4592             }
4593         }
4594       else if (old == error_mark_node)
4595         /* Ignore the undefined symbol marker.  */
4596         old = NULL_TREE;
4597       else
4598         {
4599           cp_error_at ("previous non-function declaration `%#D'", old);
4600           cp_error ("conflicts with function declaration `%#D'", decl);
4601           return decl;
4602         }
4603     }
4604
4605   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4606     {
4607       if (old && TREE_CODE (old) != OVERLOAD)
4608         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4609       else
4610         new_binding = ovl_cons (decl, old);
4611       if (flags & PUSH_USING)
4612         OVL_USED (new_binding) = 1;
4613     }
4614   else
4615     /* NAME is not ambiguous.  */
4616     new_binding = decl;
4617
4618   if (doing_global)
4619     set_namespace_binding (name, current_namespace, new_binding);
4620   else
4621     {
4622       /* We only create an OVERLOAD if there was a previous binding at
4623          this level, or if decl is a template. In the former case, we
4624          need to remove the old binding and replace it with the new
4625          binding.  We must also run through the NAMES on the binding
4626          level where the name was bound to update the chain.  */
4627
4628       if (TREE_CODE (new_binding) == OVERLOAD && old)
4629         {
4630           tree *d;
4631
4632           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4633                *d;
4634                d = &TREE_CHAIN (*d))
4635             if (*d == old
4636                 || (TREE_CODE (*d) == TREE_LIST
4637                     && TREE_VALUE (*d) == old))
4638               {
4639                 if (TREE_CODE (*d) == TREE_LIST)
4640                   /* Just replace the old binding with the new.  */
4641                   TREE_VALUE (*d) = new_binding;
4642                 else
4643                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4644                   *d = tree_cons (NULL_TREE, new_binding,
4645                                   TREE_CHAIN (*d));
4646
4647                 /* And update the CPLUS_BINDING node.  */
4648                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4649                   = new_binding;
4650                 return decl;
4651               }
4652
4653           /* We should always find a previous binding in this case.  */
4654           my_friendly_abort (0);
4655         }
4656
4657       /* Install the new binding.  */
4658       push_local_binding (name, new_binding, flags);
4659     }
4660
4661   return decl;
4662 }
4663 \f
4664 /* Generate an implicit declaration for identifier FUNCTIONID
4665    as a function of type int ().  Print a warning if appropriate.  */
4666
4667 tree
4668 implicitly_declare (functionid)
4669      tree functionid;
4670 {
4671   register tree decl;
4672
4673   /* We used to reuse an old implicit decl here,
4674      but this loses with inline functions because it can clobber
4675      the saved decl chains.  */
4676   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4677
4678   DECL_EXTERNAL (decl) = 1;
4679   TREE_PUBLIC (decl) = 1;
4680
4681   /* ISO standard says implicit declarations are in the innermost block.
4682      So we record the decl in the standard fashion.  */
4683   pushdecl (decl);
4684   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4685
4686   if (warn_implicit
4687       /* Only one warning per identifier.  */
4688       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4689     {
4690       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4691     }
4692
4693   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4694
4695   return decl;
4696 }
4697
4698 /* Return zero if the declaration NEWDECL is valid
4699    when the declaration OLDDECL (assumed to be for the same name)
4700    has already been seen.
4701    Otherwise return an error message format string with a %s
4702    where the identifier should go.  */
4703
4704 static const char *
4705 redeclaration_error_message (newdecl, olddecl)
4706      tree newdecl, olddecl;
4707 {
4708   if (TREE_CODE (newdecl) == TYPE_DECL)
4709     {
4710       /* Because C++ can put things into name space for free,
4711          constructs like "typedef struct foo { ... } foo"
4712          would look like an erroneous redeclaration.  */
4713       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4714         return 0;
4715       else
4716         return "redefinition of `%#D'";
4717     }
4718   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4719     {
4720       /* If this is a pure function, its olddecl will actually be
4721          the original initialization to `0' (which we force to call
4722          abort()).  Don't complain about redefinition in this case.  */
4723       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4724         return 0;
4725
4726       /* If both functions come from different namespaces, this is not
4727          a redeclaration - this is a conflict with a used function. */
4728       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4729           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4730         return "`%D' conflicts with used function";
4731
4732       /* We'll complain about linkage mismatches in
4733          warn_extern_redeclared_static.  */
4734
4735       /* Defining the same name twice is no good.  */
4736       if (DECL_INITIAL (olddecl) != NULL_TREE
4737           && DECL_INITIAL (newdecl) != NULL_TREE)
4738         {
4739           if (DECL_NAME (olddecl) == NULL_TREE)
4740             return "`%#D' not declared in class";
4741           else
4742             return "redefinition of `%#D'";
4743         }
4744       return 0;
4745     }
4746   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4747     {
4748       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4749            && (DECL_TEMPLATE_RESULT (newdecl)
4750                != DECL_TEMPLATE_RESULT (olddecl))
4751            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4752            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4753           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4754               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4755               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4756         return "redefinition of `%#D'";
4757       return 0;
4758     }
4759   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4760     {
4761       /* Objects declared at top level:  */
4762       /* If at least one is a reference, it's ok.  */
4763       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4764         return 0;
4765       /* Reject two definitions.  */
4766       return "redefinition of `%#D'";
4767     }
4768   else
4769     {
4770       /* Objects declared with block scope:  */
4771       /* Reject two definitions, and reject a definition
4772          together with an external reference.  */
4773       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4774         return "redeclaration of `%#D'";
4775       return 0;
4776     }
4777 }
4778 \f
4779 /* Create a new label, named ID.  */
4780
4781 static tree
4782 make_label_decl (id, local_p)
4783      tree id;
4784      int local_p;
4785 {
4786   tree decl;
4787
4788   decl = build_decl (LABEL_DECL, id, void_type_node);
4789   if (expanding_p)
4790     /* Make sure every label has an rtx.  */
4791     label_rtx (decl);
4792
4793   DECL_CONTEXT (decl) = current_function_decl;
4794   DECL_MODE (decl) = VOIDmode;
4795   C_DECLARED_LABEL_FLAG (decl) = local_p;
4796
4797   /* Say where one reference is to the label, for the sake of the
4798      error if it is not defined.  */
4799   DECL_SOURCE_LINE (decl) = lineno;
4800   DECL_SOURCE_FILE (decl) = input_filename;
4801
4802   /* Record the fact that this identifier is bound to this label.  */
4803   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4804
4805   return decl;
4806 }
4807
4808 /* Record this label on the list of used labels so that we can check
4809    at the end of the function to see whether or not the label was
4810    actually defined, and so we can check when the label is defined whether
4811    this use is valid.  */
4812
4813 static void
4814 use_label (decl)
4815      tree decl;
4816 {
4817   if (named_label_uses == NULL
4818       || named_label_uses->names_in_scope != current_binding_level->names
4819       || named_label_uses->label_decl != decl)
4820     {
4821       struct named_label_use_list *new_ent;
4822       new_ent = ((struct named_label_use_list *)
4823                  ggc_alloc (sizeof (struct named_label_use_list)));
4824       new_ent->label_decl = decl;
4825       new_ent->names_in_scope = current_binding_level->names;
4826       new_ent->binding_level = current_binding_level;
4827       new_ent->lineno_o_goto = lineno;
4828       new_ent->filename_o_goto = input_filename;
4829       new_ent->next = named_label_uses;
4830       named_label_uses = new_ent;
4831     }
4832 }
4833
4834 /* Look for a label named ID in the current function.  If one cannot
4835    be found, create one.  (We keep track of used, but undefined,
4836    labels, and complain about them at the end of a function.)  */
4837
4838 tree
4839 lookup_label (id)
4840      tree id;
4841 {
4842   tree decl;
4843   struct named_label_list *ent;
4844
4845   /* You can't use labels at global scope.  */
4846   if (current_function_decl == NULL_TREE)
4847     {
4848       error ("label `%s' referenced outside of any function",
4849              IDENTIFIER_POINTER (id));
4850       return NULL_TREE;
4851     }
4852
4853   /* See if we've already got this label.  */
4854   decl = IDENTIFIER_LABEL_VALUE (id);
4855   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4856     return decl;
4857
4858   /* Record this label on the list of labels used in this function.
4859      We do this before calling make_label_decl so that we get the
4860      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4861   ent = ((struct named_label_list *)
4862          ggc_alloc_cleared (sizeof (struct named_label_list)));
4863   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4864   ent->next = named_labels;
4865   named_labels = ent;
4866
4867   /* We need a new label.  */
4868   decl = make_label_decl (id, /*local_p=*/0);
4869
4870   /* Now fill in the information we didn't have before.  */
4871   ent->label_decl = decl;
4872
4873   return decl;
4874 }
4875
4876 /* Declare a local label named ID.  */
4877
4878 tree
4879 declare_local_label (id)
4880      tree id;
4881 {
4882   tree decl;
4883
4884   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4885      this scope we can restore the old value of
4886      IDENTIFIER_TYPE_VALUE.  */
4887   current_binding_level->shadowed_labels
4888     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4889                  current_binding_level->shadowed_labels);
4890   /* Look for the label.  */
4891   decl = make_label_decl (id, /*local_p=*/1);
4892   /* Now fill in the information we didn't have before.  */
4893   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4894
4895   return decl;
4896 }
4897
4898 /* Returns nonzero if it is ill-formed to jump past the declaration of
4899    DECL.  Returns 2 if it's also a real problem.  */
4900
4901 static int
4902 decl_jump_unsafe (decl)
4903      tree decl;
4904 {
4905   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4906     return 0;
4907
4908   if (DECL_INITIAL (decl) == NULL_TREE
4909       && pod_type_p (TREE_TYPE (decl)))
4910     return 0;
4911
4912   /* This is really only important if we're crossing an initialization.
4913      The POD stuff is just pedantry; why should it matter if the class
4914      contains a field of pointer to member type?  */
4915   if (DECL_INITIAL (decl)
4916       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4917     return 2;
4918   return 1;
4919 }
4920
4921 /* Check that a single previously seen jump to a newly defined label
4922    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4923    the jump context; NAMES are the names in scope in LEVEL at the jump
4924    context; FILE and LINE are the source position of the jump or 0.  */
4925
4926 static void
4927 check_previous_goto_1 (decl, level, names, file, line)
4928      tree decl;
4929      struct binding_level *level;
4930      tree names;
4931      const char *file;
4932      int line;
4933 {
4934   int identified = 0;
4935   int saw_eh = 0;
4936   struct binding_level *b = current_binding_level;
4937   for (; b; b = b->level_chain)
4938     {
4939       tree new_decls = b->names;
4940       tree old_decls = (b == level ? names : NULL_TREE);
4941       for (; new_decls != old_decls;
4942            new_decls = TREE_CHAIN (new_decls))
4943         {
4944           int problem = decl_jump_unsafe (new_decls);
4945           if (! problem)
4946             continue;
4947
4948           if (! identified)
4949             {
4950               if (decl)
4951                 cp_pedwarn ("jump to label `%D'", decl);
4952               else
4953                 pedwarn ("jump to case label");
4954
4955               if (file)
4956                 pedwarn_with_file_and_line (file, line, "  from here");
4957               identified = 1;
4958             }
4959
4960           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4961             /* Can't skip init of __exception_info.  */
4962             cp_error_at ("  enters catch block", new_decls);
4963           else if (problem > 1)
4964             cp_error_at ("  crosses initialization of `%#D'",
4965                          new_decls);
4966           else
4967             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4968                            new_decls);
4969         }
4970
4971       if (b == level)
4972         break;
4973       if (b->eh_region && ! saw_eh)
4974         {
4975           if (! identified)
4976             {
4977               if (decl)
4978                 cp_pedwarn ("jump to label `%D'", decl);
4979               else
4980                 pedwarn ("jump to case label");
4981
4982               if (file)
4983                 pedwarn_with_file_and_line (file, line, "  from here");
4984               identified = 1;
4985             }
4986           error ("  enters try block");
4987           saw_eh = 1;
4988         }
4989     }
4990 }
4991
4992 static void
4993 check_previous_goto (use)
4994      struct named_label_use_list *use;
4995 {
4996   check_previous_goto_1 (use->label_decl, use->binding_level,
4997                          use->names_in_scope, use->filename_o_goto,
4998                          use->lineno_o_goto);
4999 }
5000
5001 static void
5002 check_switch_goto (level)
5003      struct binding_level *level;
5004 {
5005   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5006 }
5007
5008 /* Check that any previously seen jumps to a newly defined label DECL
5009    are OK.  Called by define_label.  */
5010
5011 static void
5012 check_previous_gotos (decl)
5013      tree decl;
5014 {
5015   struct named_label_use_list **usep;
5016
5017   if (! TREE_USED (decl))
5018     return;
5019
5020   for (usep = &named_label_uses; *usep; )
5021     {
5022       struct named_label_use_list *use = *usep;
5023       if (use->label_decl == decl)
5024         {
5025           check_previous_goto (use);
5026           *usep = use->next;
5027         }
5028       else
5029         usep = &(use->next);
5030     }
5031 }
5032
5033 /* Check that a new jump to a label DECL is OK.  Called by
5034    finish_goto_stmt.  */
5035
5036 void
5037 check_goto (decl)
5038      tree decl;
5039 {
5040   int identified = 0;
5041   tree bad;
5042   struct named_label_list *lab;
5043
5044   /* We can't know where a computed goto is jumping.  So we assume
5045      that it's OK.  */
5046   if (! DECL_P (decl))
5047     return;
5048
5049   /* If the label hasn't been defined yet, defer checking.  */
5050   if (! DECL_INITIAL (decl))
5051     {
5052       use_label (decl);
5053       return;
5054     }
5055
5056   for (lab = named_labels; lab; lab = lab->next)
5057     if (decl == lab->label_decl)
5058       break;
5059
5060   /* If the label is not on named_labels it's a gcc local label, so
5061      it must be in an outer scope, so jumping to it is always OK.  */
5062   if (lab == 0)
5063     return;
5064
5065   if ((lab->eh_region || lab->bad_decls) && !identified)
5066     {
5067       cp_pedwarn_at ("jump to label `%D'", decl);
5068       pedwarn ("  from here");
5069       identified = 1;
5070     }
5071
5072   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5073     {
5074       tree b = TREE_VALUE (bad);
5075       int u = decl_jump_unsafe (b);
5076
5077       if (u > 1 && DECL_ARTIFICIAL (b))
5078         /* Can't skip init of __exception_info.  */
5079         cp_error_at ("  enters catch block", b);
5080       else if (u > 1)
5081         cp_error_at ("  skips initialization of `%#D'", b);
5082       else
5083         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5084     }
5085
5086   if (lab->eh_region)
5087     error ("  enters try block");
5088 }
5089
5090 /* Define a label, specifying the location in the source file.
5091    Return the LABEL_DECL node for the label, if the definition is valid.
5092    Otherwise return 0.  */
5093
5094 tree
5095 define_label (filename, line, name)
5096      const char *filename;
5097      int line;
5098      tree name;
5099 {
5100   tree decl = lookup_label (name);
5101   struct named_label_list *ent;
5102
5103   for (ent = named_labels; ent; ent = ent->next)
5104     if (ent->label_decl == decl)
5105       break;
5106
5107   /* After labels, make any new cleanups go into their
5108      own new (temporary) binding contour.  */
5109   current_binding_level->more_cleanups_ok = 0;
5110
5111   if (name == get_identifier ("wchar_t"))
5112     cp_pedwarn ("label named wchar_t");
5113
5114   if (DECL_INITIAL (decl) != NULL_TREE)
5115     {
5116       cp_error ("duplicate label `%D'", decl);
5117       return 0;
5118     }
5119   else
5120     {
5121       /* Mark label as having been defined.  */
5122       DECL_INITIAL (decl) = error_mark_node;
5123       /* Say where in the source.  */
5124       DECL_SOURCE_FILE (decl) = filename;
5125       DECL_SOURCE_LINE (decl) = line;
5126       if (ent)
5127         {
5128           ent->names_in_scope = current_binding_level->names;
5129           ent->binding_level = current_binding_level;
5130         }
5131       check_previous_gotos (decl);
5132       current_function_return_value = NULL_TREE;
5133       return decl;
5134     }
5135 }
5136
5137 struct cp_switch
5138 {
5139   struct binding_level *level;
5140   struct cp_switch *next;
5141 };
5142
5143 static struct cp_switch *switch_stack;
5144
5145 void
5146 push_switch ()
5147 {
5148   struct cp_switch *p
5149     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5150   p->level = current_binding_level;
5151   p->next = switch_stack;
5152   switch_stack = p;
5153 }
5154
5155 void
5156 pop_switch ()
5157 {
5158   struct cp_switch *cs;
5159
5160   cs = switch_stack;
5161   switch_stack = switch_stack->next;
5162   free (cs);
5163 }
5164
5165 /* Note that we've seen a definition of a case label, and complain if this
5166    is a bad place for one.  */
5167
5168 void
5169 define_case_label ()
5170 {
5171   tree cleanup = last_cleanup_this_contour ();
5172
5173   if (! switch_stack)
5174     /* Don't crash; we'll complain in do_case.  */
5175     return;
5176
5177   if (cleanup)
5178     {
5179       static int explained = 0;
5180       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5181       warning ("where case label appears here");
5182       if (!explained)
5183         {
5184           warning ("(enclose actions of previous case statements requiring");
5185           warning ("destructors in their own binding contours.)");
5186           explained = 1;
5187         }
5188     }
5189
5190   check_switch_goto (switch_stack->level);
5191
5192   /* After labels, make any new cleanups go into their
5193      own new (temporary) binding contour.  */
5194
5195   current_binding_level->more_cleanups_ok = 0;
5196   current_function_return_value = NULL_TREE;
5197 }
5198 \f
5199 /* Return the list of declarations of the current level.
5200    Note that this list is in reverse order unless/until
5201    you nreverse it; and when you do nreverse it, you must
5202    store the result back using `storedecls' or you will lose.  */
5203
5204 tree
5205 getdecls ()
5206 {
5207   return current_binding_level->names;
5208 }
5209
5210 /* Return the list of type-tags (for structs, etc) of the current level.  */
5211
5212 tree
5213 gettags ()
5214 {
5215   return current_binding_level->tags;
5216 }
5217
5218 /* Store the list of declarations of the current level.
5219    This is done for the parameter declarations of a function being defined,
5220    after they are modified in the light of any missing parameters.  */
5221
5222 static void
5223 storedecls (decls)
5224      tree decls;
5225 {
5226   current_binding_level->names = decls;
5227 }
5228
5229 /* Similarly, store the list of tags of the current level.  */
5230
5231 void
5232 storetags (tags)
5233      tree tags;
5234 {
5235   current_binding_level->tags = tags;
5236 }
5237 \f
5238 /* Given NAME, an IDENTIFIER_NODE,
5239    return the structure (or union or enum) definition for that name.
5240    Searches binding levels from BINDING_LEVEL up to the global level.
5241    If THISLEVEL_ONLY is nonzero, searches only the specified context
5242    (but skips any tag-transparent contexts to find one that is
5243    meaningful for tags).
5244    FORM says which kind of type the caller wants;
5245    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5246    If the wrong kind of type is found, and it's not a template, an error is
5247    reported.  */
5248
5249 static tree
5250 lookup_tag (form, name, binding_level, thislevel_only)
5251      enum tree_code form;
5252      tree name;
5253      struct binding_level *binding_level;
5254      int thislevel_only;
5255 {
5256   register struct binding_level *level;
5257   /* Non-zero if, we should look past a template parameter level, even
5258      if THISLEVEL_ONLY.  */
5259   int allow_template_parms_p = 1;
5260
5261   for (level = binding_level; level; level = level->level_chain)
5262     {
5263       register tree tail;
5264       if (ANON_AGGRNAME_P (name))
5265         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5266           {
5267             /* There's no need for error checking here, because
5268                anon names are unique throughout the compilation.  */
5269             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5270               return TREE_VALUE (tail);
5271           }
5272       else if (level->namespace_p)
5273         /* Do namespace lookup. */
5274         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5275           {
5276             tree old = binding_for_name (name, tail);
5277
5278             /* If we just skipped past a template parameter level,
5279                even though THISLEVEL_ONLY, and we find a template
5280                class declaration, then we use the _TYPE node for the
5281                template.  See the example below.  */
5282             if (thislevel_only && !allow_template_parms_p
5283                 && old && BINDING_VALUE (old)
5284                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5285               old = TREE_TYPE (BINDING_VALUE (old));
5286             else
5287               old = BINDING_TYPE (old);
5288
5289             /* If it has an original type, it is a typedef, and we
5290                should not return it.  */
5291             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5292               old = NULL_TREE;
5293             if (old && TREE_CODE (old) != form
5294                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5295               {
5296                 cp_error ("`%#D' redeclared as %C", old, form);
5297                 return NULL_TREE;
5298               }
5299             if (old)
5300               return old;
5301             if (thislevel_only || tail == global_namespace)
5302               return NULL_TREE;
5303           }
5304       else
5305         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5306           {
5307             if (TREE_PURPOSE (tail) == name)
5308               {
5309                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5310                 /* Should tighten this up; it'll probably permit
5311                    UNION_TYPE and a struct template, for example.  */
5312                 if (code != form
5313                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5314                   {
5315                     /* Definition isn't the kind we were looking for.  */
5316                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5317                               form);
5318                     return NULL_TREE;
5319                   }
5320                 return TREE_VALUE (tail);
5321               }
5322           }
5323       if (thislevel_only && ! level->tag_transparent)
5324         {
5325           if (level->template_parms_p && allow_template_parms_p)
5326             {
5327               /* We must deal with cases like this:
5328
5329                    template <class T> struct S;
5330                    template <class T> struct S {};
5331
5332                  When looking up `S', for the second declaration, we
5333                  would like to find the first declaration.  But, we
5334                  are in the pseudo-global level created for the
5335                  template parameters, rather than the (surrounding)
5336                  namespace level.  Thus, we keep going one more level,
5337                  even though THISLEVEL_ONLY is non-zero.  */
5338               allow_template_parms_p = 0;
5339               continue;
5340             }
5341           else
5342             return NULL_TREE;
5343         }
5344     }
5345   return NULL_TREE;
5346 }
5347
5348 #if 0
5349 void
5350 set_current_level_tags_transparency (tags_transparent)
5351      int tags_transparent;
5352 {
5353   current_binding_level->tag_transparent = tags_transparent;
5354 }
5355 #endif
5356
5357 /* Given a type, find the tag that was defined for it and return the tag name.
5358    Otherwise return 0.  However, the value can never be 0
5359    in the cases in which this is used.
5360
5361    C++: If NAME is non-zero, this is the new name to install.  This is
5362    done when replacing anonymous tags with real tag names.  */
5363
5364 static tree
5365 lookup_tag_reverse (type, name)
5366      tree type;
5367      tree name;
5368 {
5369   register struct binding_level *level;
5370
5371   for (level = current_binding_level; level; level = level->level_chain)
5372     {
5373       register tree tail;
5374       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5375         {
5376           if (TREE_VALUE (tail) == type)
5377             {
5378               if (name)
5379                 TREE_PURPOSE (tail) = name;
5380               return TREE_PURPOSE (tail);
5381             }
5382         }
5383     }
5384   return NULL_TREE;
5385 }
5386 \f
5387 /* Look up NAME in the NAMESPACE.  */
5388
5389 tree
5390 lookup_namespace_name (namespace, name)
5391      tree namespace, name;
5392 {
5393   tree val;
5394   tree template_id = NULL_TREE;
5395
5396   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5397
5398   if (TREE_CODE (name) == NAMESPACE_DECL)
5399     /* This happens for A::B<int> when B is a namespace. */
5400     return name;
5401   else if (TREE_CODE (name) == TEMPLATE_DECL)
5402     {
5403       /* This happens for A::B where B is a template, and there are no
5404          template arguments.  */
5405       cp_error ("invalid use of `%D'", name);
5406       return error_mark_node;
5407     }
5408
5409   namespace = ORIGINAL_NAMESPACE (namespace);
5410
5411   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5412     {
5413       template_id = name;
5414       name = TREE_OPERAND (name, 0);
5415       if (TREE_CODE (name) == OVERLOAD)
5416         name = DECL_NAME (OVL_CURRENT (name));
5417       else if (DECL_P (name))
5418         name = DECL_NAME (name);
5419     }
5420
5421   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5422
5423   val = make_node (CPLUS_BINDING);
5424   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5425     return error_mark_node;
5426
5427   if (BINDING_VALUE (val))
5428     {
5429       val = BINDING_VALUE (val);
5430
5431       if (template_id)
5432         {
5433           if (DECL_CLASS_TEMPLATE_P (val))
5434             val = lookup_template_class (val,
5435                                          TREE_OPERAND (template_id, 1),
5436                                          /*in_decl=*/NULL_TREE,
5437                                          /*context=*/NULL_TREE,
5438                                          /*entering_scope=*/0);
5439           else if (DECL_FUNCTION_TEMPLATE_P (val)
5440                    || TREE_CODE (val) == OVERLOAD)
5441             val = lookup_template_function (val,
5442                                             TREE_OPERAND (template_id, 1));
5443           else
5444             {
5445               cp_error ("`%D::%D' is not a template",
5446                         namespace, name);
5447               return error_mark_node;
5448             }
5449         }
5450
5451       /* If we have a single function from a using decl, pull it out.  */
5452       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5453         val = OVL_FUNCTION (val);
5454       return val;
5455     }
5456
5457   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5458   return error_mark_node;
5459 }
5460
5461 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5462
5463 static unsigned long
5464 typename_hash (k)
5465      hash_table_key k;
5466 {
5467   unsigned long hash;
5468   tree t;
5469
5470   t = (tree) k;
5471   hash = (((unsigned long) TYPE_CONTEXT (t))
5472           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5473
5474   return hash;
5475 }
5476
5477 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5478
5479 static boolean
5480 typename_compare (k1, k2)
5481      hash_table_key k1;
5482      hash_table_key k2;
5483 {
5484   tree t1;
5485   tree t2;
5486   tree d1;
5487   tree d2;
5488
5489   t1 = (tree) k1;
5490   t2 = (tree) k2;
5491   d1 = TYPE_NAME (t1);
5492   d2 = TYPE_NAME (t2);
5493
5494   return (DECL_NAME (d1) == DECL_NAME (d2)
5495           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5496           && ((TREE_TYPE (t1) != NULL_TREE)
5497               == (TREE_TYPE (t2) != NULL_TREE))
5498           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5499           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5500 }
5501
5502 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5503    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5504    is non-NULL, this type is being created by the implicit typename
5505    extension, and BASE_TYPE is a type named `t' in some base class of
5506    `T' which depends on template parameters.
5507
5508    Returns the new TYPENAME_TYPE.  */
5509
5510 tree
5511 build_typename_type (context, name, fullname, base_type)
5512      tree context;
5513      tree name;
5514      tree fullname;
5515      tree base_type;
5516 {
5517   tree t;
5518   tree d;
5519   struct hash_entry* e;
5520
5521   static struct hash_table ht;
5522
5523   if (!ht.table)
5524     {
5525       static struct hash_table *h = &ht;
5526       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5527                             &typename_compare))
5528         fatal ("virtual memory exhausted");
5529       ggc_add_tree_hash_table_root (&h, 1);
5530     }
5531
5532   /* Build the TYPENAME_TYPE.  */
5533   t = make_aggr_type (TYPENAME_TYPE);
5534   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5535   TYPENAME_TYPE_FULLNAME (t) = fullname;
5536   TREE_TYPE (t) = base_type;
5537
5538   /* Build the corresponding TYPE_DECL.  */
5539   d = build_decl (TYPE_DECL, name, t);
5540   TYPE_NAME (TREE_TYPE (d)) = d;
5541   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5542   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5543   DECL_ARTIFICIAL (d) = 1;
5544
5545   /* See if we already have this type.  */
5546   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5547   if (e)
5548     t = (tree) e->key;
5549   else
5550     /* Insert the type into the table.  */
5551     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5552
5553   return t;
5554 }
5555
5556 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5557    unless an error occurs, in which case error_mark_node is returned.
5558    If COMPLAIN zero, don't complain about any errors that occur.  */
5559
5560 tree
5561 make_typename_type (context, name, complain)
5562      tree context, name;
5563      int complain;
5564 {
5565   tree fullname;
5566
5567   if (TYPE_P (name))
5568     {
5569       if (!(TYPE_LANG_SPECIFIC (name)
5570             && (CLASSTYPE_IS_TEMPLATE (name)
5571                 || CLASSTYPE_USE_TEMPLATE (name))))
5572         name = TYPE_IDENTIFIER (name);
5573       else
5574         /* Create a TEMPLATE_ID_EXPR for the type.  */
5575         name = build_nt (TEMPLATE_ID_EXPR,
5576                          CLASSTYPE_TI_TEMPLATE (name),
5577                          CLASSTYPE_TI_ARGS (name));
5578     }
5579   else if (TREE_CODE (name) == TYPE_DECL)
5580     name = DECL_NAME (name);
5581
5582   fullname = name;
5583
5584   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5585     {
5586       name = TREE_OPERAND (name, 0);
5587       if (TREE_CODE (name) == TEMPLATE_DECL)
5588         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5589     }
5590   if (TREE_CODE (name) != IDENTIFIER_NODE)
5591     my_friendly_abort (2000);
5592
5593   if (TREE_CODE (context) == NAMESPACE_DECL)
5594     {
5595       /* We can get here from typename_sub0 in the explicit_template_type
5596          expansion.  Just fail.  */
5597       if (complain)
5598         cp_error ("no class template named `%#T' in `%#T'",
5599                   name, context);
5600       return error_mark_node;
5601     }
5602
5603   if (! uses_template_parms (context)
5604       || currently_open_class (context))
5605     {
5606       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5607         {
5608           tree tmpl = NULL_TREE;
5609           if (IS_AGGR_TYPE (context))
5610             tmpl = lookup_field (context, name, 0, 0);
5611           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5612             {
5613               if (complain)
5614                 cp_error ("no class template named `%#T' in `%#T'",
5615                           name, context);
5616               return error_mark_node;
5617             }
5618
5619           return lookup_template_class (tmpl,
5620                                         TREE_OPERAND (fullname, 1),
5621                                         NULL_TREE, context,
5622                                         /*entering_scope=*/0);
5623         }
5624       else
5625         {
5626           tree t;
5627
5628           if (!IS_AGGR_TYPE (context))
5629             {
5630               if (complain)
5631                 cp_error ("no type named `%#T' in `%#T'", name, context);
5632               return error_mark_node;
5633             }
5634
5635           t = lookup_field (context, name, 0, 1);
5636           if (t)
5637             return TREE_TYPE (t);
5638         }
5639     }
5640
5641   /* If the CONTEXT is not a template type, then either the field is
5642      there now or its never going to be.  */
5643   if (!uses_template_parms (context))
5644     {
5645       if (complain)
5646         cp_error ("no type named `%#T' in `%#T'", name, context);
5647       return error_mark_node;
5648     }
5649
5650
5651   return build_typename_type (context, name, fullname,  NULL_TREE);
5652 }
5653
5654 /* Select the right _DECL from multiple choices. */
5655
5656 static tree
5657 select_decl (binding, flags)
5658      tree binding;
5659      int flags;
5660 {
5661   tree val;
5662   val = BINDING_VALUE (binding);
5663   if (LOOKUP_NAMESPACES_ONLY (flags))
5664     {
5665       /* We are not interested in types. */
5666       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5667         return val;
5668       return NULL_TREE;
5669     }
5670
5671   /* If we could have a type and
5672      we have nothing or we need a type and have none.  */
5673   if (BINDING_TYPE (binding)
5674       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5675                    && TREE_CODE (val) != TYPE_DECL)))
5676     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5677   /* Don't return non-types if we really prefer types. */
5678   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5679            && (TREE_CODE (val) != TEMPLATE_DECL
5680                || !DECL_CLASS_TEMPLATE_P (val)))
5681     val = NULL_TREE;
5682
5683   return val;
5684 }
5685
5686 /* Unscoped lookup of a global: iterate over current namespaces,
5687    considering using-directives.  If SPACESP is non-NULL, store a list
5688    of the namespaces we've considered in it.  */
5689
5690 tree
5691 unqualified_namespace_lookup (name, flags, spacesp)
5692      tree name;
5693      int flags;
5694      tree *spacesp;
5695 {
5696   tree b = make_node (CPLUS_BINDING);
5697   tree initial = current_decl_namespace();
5698   tree scope = initial;
5699   tree siter;
5700   struct binding_level *level;
5701   tree val = NULL_TREE;
5702
5703   if (spacesp)
5704     *spacesp = NULL_TREE;
5705
5706   for (; !val; scope = CP_DECL_CONTEXT (scope))
5707     {
5708       if (spacesp)
5709         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5710       val = binding_for_name (name, scope);
5711
5712       /* Initialize binding for this context. */
5713       BINDING_VALUE (b) = BINDING_VALUE (val);
5714       BINDING_TYPE (b) = BINDING_TYPE (val);
5715
5716       /* Add all _DECLs seen through local using-directives. */
5717       for (level = current_binding_level;
5718            !level->namespace_p;
5719            level = level->level_chain)
5720         if (!lookup_using_namespace (name, b, level->using_directives,
5721                                      scope, flags, spacesp))
5722           /* Give up because of error. */
5723           return error_mark_node;
5724
5725       /* Add all _DECLs seen through global using-directives. */
5726       /* XXX local and global using lists should work equally. */
5727       siter = initial;
5728       while (1)
5729         {
5730           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5731                                        scope, flags, spacesp))
5732             /* Give up because of error. */
5733             return error_mark_node;
5734           if (siter == scope) break;
5735           siter = CP_DECL_CONTEXT (siter);
5736         }
5737
5738       val = select_decl (b, flags);
5739       if (scope == global_namespace)
5740         break;
5741     }
5742   return val;
5743 }
5744
5745 /* Combine prefer_type and namespaces_only into flags.  */
5746
5747 static int
5748 lookup_flags (prefer_type, namespaces_only)
5749   int prefer_type, namespaces_only;
5750 {
5751   if (namespaces_only)
5752     return LOOKUP_PREFER_NAMESPACES;
5753   if (prefer_type > 1)
5754     return LOOKUP_PREFER_TYPES;
5755   if (prefer_type > 0)
5756     return LOOKUP_PREFER_BOTH;
5757   return 0;
5758 }
5759
5760 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5761    ignore it or not.  Subroutine of lookup_name_real.  */
5762
5763 static tree
5764 qualify_lookup (val, flags)
5765      tree val;
5766      int flags;
5767 {
5768   if (val == NULL_TREE)
5769     return val;
5770   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5771     return val;
5772   if ((flags & LOOKUP_PREFER_TYPES)
5773       && (TREE_CODE (val) == TYPE_DECL
5774           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5775               && DECL_CLASS_TEMPLATE_P (val))))
5776     return val;
5777   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5778     return NULL_TREE;
5779   return val;
5780 }
5781
5782 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5783    that.  */
5784
5785 static void
5786 warn_about_implicit_typename_lookup (typename, binding)
5787      tree typename;
5788      tree binding;
5789 {
5790   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5791   tree name = DECL_NAME (typename);
5792
5793   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5794          && CLASSTYPE_TEMPLATE_INFO (subtype)
5795          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5796       && ! (TREE_CODE (binding) == TYPE_DECL
5797             && same_type_p (TREE_TYPE (binding), subtype)))
5798     {
5799       cp_warning ("lookup of `%D' finds `%#D'",
5800                   name, binding);
5801       cp_warning ("  instead of `%D' from dependent base class",
5802                   typename);
5803       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5804                   constructor_name (current_class_type), name);
5805     }
5806 }
5807
5808 /* Look up NAME in the current binding level and its superiors in the
5809    namespace of variables, functions and typedefs.  Return a ..._DECL
5810    node of some kind representing its definition if there is only one
5811    such declaration, or return a TREE_LIST with all the overloaded
5812    definitions if there are many, or return 0 if it is undefined.
5813
5814    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5815    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5816    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5817    Otherwise we prefer non-TYPE_DECLs.
5818
5819    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5820    using IDENTIFIER_CLASS_VALUE.  */
5821
5822 static tree
5823 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5824      tree name;
5825      int prefer_type, nonclass, namespaces_only;
5826 {
5827   tree t;
5828   tree val = NULL_TREE;
5829   int yylex = 0;
5830   tree from_obj = NULL_TREE;
5831   int flags;
5832   int val_is_implicit_typename = 0;
5833
5834   /* Hack: copy flag set by parser, if set. */
5835   if (only_namespace_names)
5836     namespaces_only = 1;
5837
5838   if (prefer_type == -2)
5839     {
5840       extern int looking_for_typename;
5841       tree type = NULL_TREE;
5842
5843       yylex = 1;
5844       prefer_type = looking_for_typename;
5845
5846       flags = lookup_flags (prefer_type, namespaces_only);
5847       /* If the next thing is '<', class templates are types. */
5848       if (looking_for_template)
5849         flags |= LOOKUP_TEMPLATES_EXPECTED;
5850
5851       /* std:: becomes :: for now.  */
5852       if (got_scope == std_node)
5853         got_scope = void_type_node;
5854
5855       if (got_scope)
5856         type = got_scope;
5857       else if (got_object != error_mark_node)
5858         type = got_object;
5859
5860       if (type)
5861         {
5862           if (type == error_mark_node)
5863             return error_mark_node;
5864           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5865             type = TREE_TYPE (type);
5866
5867           if (TYPE_P (type))
5868             type = complete_type (type);
5869
5870           if (TREE_CODE (type) == VOID_TYPE)
5871             type = global_namespace;
5872           if (TREE_CODE (type) == NAMESPACE_DECL)
5873             {
5874               val = make_node (CPLUS_BINDING);
5875               flags |= LOOKUP_COMPLAIN;
5876               if (!qualified_lookup_using_namespace (name, type, val, flags))
5877                 return NULL_TREE;
5878               val = select_decl (val, flags);
5879             }
5880           else if (! IS_AGGR_TYPE (type)
5881                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5882                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5883                    || TREE_CODE (type) == TYPENAME_TYPE)
5884             /* Someone else will give an error about this if needed.  */
5885             val = NULL_TREE;
5886           else if (type == current_class_type)
5887             val = IDENTIFIER_CLASS_VALUE (name);
5888           else
5889             {
5890               val = lookup_member (type, name, 0, prefer_type);
5891               type_access_control (type, val);
5892             }
5893         }
5894       else
5895         val = NULL_TREE;
5896
5897       if (got_scope)
5898         goto done;
5899       else if (got_object && val)
5900         from_obj = val;
5901     }
5902   else
5903     {
5904       flags = lookup_flags (prefer_type, namespaces_only);
5905       /* If we're not parsing, we need to complain. */
5906       flags |= LOOKUP_COMPLAIN;
5907     }
5908
5909   /* First, look in non-namespace scopes.  */
5910
5911   if (current_class_type == NULL_TREE)
5912     nonclass = 1;
5913
5914   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5915     {
5916       tree binding;
5917
5918       if (!LOCAL_BINDING_P (t) && nonclass)
5919         /* We're not looking for class-scoped bindings, so keep going.  */
5920         continue;
5921
5922       /* If this is the kind of thing we're looking for, we're done.  */
5923       if (qualify_lookup (BINDING_VALUE (t), flags))
5924         binding = BINDING_VALUE (t);
5925       else if ((flags & LOOKUP_PREFER_TYPES)
5926                && qualify_lookup (BINDING_TYPE (t), flags))
5927         binding = BINDING_TYPE (t);
5928       else
5929         binding = NULL_TREE;
5930
5931       /* Handle access control on types from enclosing or base classes.  */
5932       if (binding && ! yylex
5933           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5934         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5935
5936       if (binding
5937           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5938         {
5939           if (val_is_implicit_typename && !yylex)
5940             warn_about_implicit_typename_lookup (val, binding);
5941           val = binding;
5942           val_is_implicit_typename
5943             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5944           if (!val_is_implicit_typename)
5945             break;
5946         }
5947     }
5948
5949   /* Now lookup in namespace scopes.  */
5950   if (!val || val_is_implicit_typename)
5951     {
5952       t = unqualified_namespace_lookup (name, flags, 0);
5953       if (t)
5954         {
5955           if (val_is_implicit_typename && !yylex)
5956             warn_about_implicit_typename_lookup (val, t);
5957           val = t;
5958         }
5959     }
5960
5961  done:
5962   if (val)
5963     {
5964       /* This should only warn about types used in qualified-ids.  */
5965       if (from_obj && from_obj != val)
5966         {
5967           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5968               && TREE_CODE (val) == TYPE_DECL
5969               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5970             {
5971               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5972                           name, got_object, TREE_TYPE (from_obj));
5973               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5974                           TREE_TYPE (val));
5975             }
5976
5977           /* We don't change val to from_obj if got_object depends on
5978              template parms because that breaks implicit typename for
5979              destructor calls.  */
5980           if (! uses_template_parms (got_object))
5981             val = from_obj;
5982         }
5983
5984       /* If we have a single function from a using decl, pull it out.  */
5985       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5986         val = OVL_FUNCTION (val);
5987     }
5988   else if (from_obj)
5989     val = from_obj;
5990
5991   return val;
5992 }
5993
5994 tree
5995 lookup_name_nonclass (name)
5996      tree name;
5997 {
5998   return lookup_name_real (name, 0, 1, 0);
5999 }
6000
6001 tree
6002 lookup_function_nonclass (name, args)
6003      tree name;
6004      tree args;
6005 {
6006   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6007 }
6008
6009 tree
6010 lookup_name_namespace_only (name)
6011      tree name;
6012 {
6013   /* type-or-namespace, nonclass, namespace_only */
6014   return lookup_name_real (name, 1, 1, 1);
6015 }
6016
6017 tree
6018 lookup_name (name, prefer_type)
6019      tree name;
6020      int prefer_type;
6021 {
6022   return lookup_name_real (name, prefer_type, 0, 0);
6023 }
6024
6025 /* Similar to `lookup_name' but look only in the innermost non-class
6026    binding level.  */
6027
6028 tree
6029 lookup_name_current_level (name)
6030      tree name;
6031 {
6032   struct binding_level *b;
6033   tree t = NULL_TREE;
6034
6035   b = current_binding_level;
6036   while (b->parm_flag == 2)
6037     b = b->level_chain;
6038
6039   if (b->namespace_p)
6040     {
6041       t = IDENTIFIER_NAMESPACE_VALUE (name);
6042
6043       /* extern "C" function() */
6044       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6045         t = TREE_VALUE (t);
6046     }
6047   else if (IDENTIFIER_BINDING (name)
6048            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6049     {
6050       while (1)
6051         {
6052           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6053             return IDENTIFIER_VALUE (name);
6054
6055           if (b->keep == 2)
6056             b = b->level_chain;
6057           else
6058             break;
6059         }
6060     }
6061
6062   return t;
6063 }
6064
6065 /* Like lookup_name_current_level, but for types.  */
6066
6067 tree
6068 lookup_type_current_level (name)
6069      tree name;
6070 {
6071   register tree t = NULL_TREE;
6072
6073   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6074
6075   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6076       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6077     {
6078       struct binding_level *b = current_binding_level;
6079       while (1)
6080         {
6081           if (purpose_member (name, b->type_shadowed))
6082             return REAL_IDENTIFIER_TYPE_VALUE (name);
6083           if (b->keep == 2)
6084             b = b->level_chain;
6085           else
6086             break;
6087         }
6088     }
6089
6090   return t;
6091 }
6092
6093 void
6094 begin_only_namespace_names ()
6095 {
6096   only_namespace_names = 1;
6097 }
6098
6099 void
6100 end_only_namespace_names ()
6101 {
6102   only_namespace_names = 0;
6103 }
6104 \f
6105 /* Push the declarations of builtin types into the namespace.
6106    RID_INDEX, if < CP_RID_MAX is the index of the builtin type
6107    in the array RID_POINTERS.  NAME is the name used when looking
6108    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6109
6110 static void
6111 record_builtin_type (rid_index, name, type)
6112      enum rid rid_index;
6113      const char *name;
6114      tree type;
6115 {
6116   tree rname = NULL_TREE, tname = NULL_TREE;
6117   tree tdecl = NULL_TREE;
6118
6119   if ((int) rid_index < (int) CP_RID_MAX)
6120     rname = ridpointers[(int) rid_index];
6121   if (name)
6122     tname = get_identifier (name);
6123
6124   TYPE_BUILT_IN (type) = 1;
6125
6126   if (tname)
6127     {
6128       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6129       set_identifier_type_value (tname, NULL_TREE);
6130       if ((int) rid_index < (int) CP_RID_MAX)
6131         /* Built-in types live in the global namespace. */
6132         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6133     }
6134   if (rname != NULL_TREE)
6135     {
6136       if (tname != NULL_TREE)
6137         {
6138           set_identifier_type_value (rname, NULL_TREE);
6139           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6140         }
6141       else
6142         {
6143           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6144           set_identifier_type_value (rname, NULL_TREE);
6145         }
6146     }
6147 }
6148
6149 /* Record one of the standard Java types.
6150  * Declare it as having the given NAME.
6151  * If SIZE > 0, it is the size of one of the integral types;
6152  * otherwise it is the negative of the size of one of the other types.  */
6153
6154 static tree
6155 record_builtin_java_type (name, size)
6156      const char *name;
6157      int size;
6158 {
6159   tree type, decl;
6160   if (size > 0)
6161     type = make_signed_type (size);
6162   else if (size > -32)
6163     { /* "__java_char" or ""__java_boolean". */
6164       type = make_unsigned_type (-size);
6165       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6166     }
6167   else
6168     { /* "__java_float" or ""__java_double". */
6169       type = make_node (REAL_TYPE);
6170       TYPE_PRECISION (type) = - size;
6171       layout_type (type);
6172     }
6173   record_builtin_type (CP_RID_MAX, name, type);
6174   decl = TYPE_NAME (type);
6175
6176   /* Suppress generate debug symbol entries for these types,
6177      since for normal C++ they are just clutter.
6178      However, push_lang_context undoes this if extern "Java" is seen. */
6179   DECL_IGNORED_P (decl) = 1;
6180
6181   TYPE_FOR_JAVA (type) = 1;
6182   return type;
6183 }
6184
6185 /* Push a type into the namespace so that the back-ends ignore it. */
6186
6187 static void
6188 record_unknown_type (type, name)
6189      tree type;
6190      const char *name;
6191 {
6192   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6193   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6194   DECL_IGNORED_P (decl) = 1;
6195   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6196   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6197   TYPE_ALIGN (type) = 1;
6198   TYPE_USER_ALIGN (type) = 0;
6199   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6200 }
6201
6202 /* An string for which we should create an IDENTIFIER_NODE at
6203    startup.  */
6204
6205 typedef struct predefined_identifier
6206 {
6207   /* The name of the identifier.  */
6208   const char *name;
6209   /* The place where the IDENTIFIER_NODE should be stored.  */
6210   tree *node;
6211   /* Non-zero if this is the name of a constructor or destructor.  */
6212   int ctor_or_dtor_p;
6213 } predefined_identifier;
6214
6215 /* Create all the predefined identifiers.  */
6216
6217 static void
6218 initialize_predefined_identifiers ()
6219 {
6220   struct predefined_identifier *pid;
6221
6222   /* A table of identifiers to create at startup.  */
6223   static predefined_identifier predefined_identifiers[] = {
6224     { "C++", &lang_name_cplusplus, 0 },
6225     { "C", &lang_name_c, 0 },
6226     { "Java", &lang_name_java, 0 },
6227     { CTOR_NAME, &ctor_identifier, 1 },
6228     { "__base_ctor", &base_ctor_identifier, 1 },
6229     { "__comp_ctor", &complete_ctor_identifier, 1 },
6230     { DTOR_NAME, &dtor_identifier, 1 },
6231     { "__comp_dtor", &complete_dtor_identifier, 1 },
6232     { "__base_dtor", &base_dtor_identifier, 1 },
6233     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6234     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6235     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6236     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6237     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6238     { "nelts", &nelts_identifier, 0 },
6239     { THIS_NAME, &this_identifier, 0 },
6240     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6241     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6242     { "_vptr", &vptr_identifier, 0 },
6243     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6244     { "__vtt_parm", &vtt_parm_identifier, 0 },
6245     { "std", &std_identifier, 0 },
6246     { NULL, NULL, 0 }
6247   };
6248
6249   for (pid = predefined_identifiers; pid->name; ++pid)
6250     {
6251       *pid->node = get_identifier (pid->name);
6252       if (pid->ctor_or_dtor_p)
6253         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6254     }
6255 }
6256
6257 /* Create the predefined scalar types of C,
6258    and some nodes representing standard constants (0, 1, (void *)0).
6259    Initialize the global binding level.
6260    Make definitions for built-in primitive functions.  */
6261
6262 void
6263 init_decl_processing ()
6264 {
6265   tree fields[20];
6266   int wchar_type_size;
6267   tree array_domain_type;
6268
6269   /* Check to see that the user did not specify an invalid combination
6270      of command-line options.  */
6271   if (flag_new_abi && !flag_vtable_thunks)
6272     fatal ("the new ABI requires vtable thunks");
6273
6274   /* Create all the identifiers we need.  */
6275   initialize_predefined_identifiers ();
6276
6277   /* Let the back-end now how to save and restore language-specific
6278      per-function globals.  */
6279   init_lang_status = &push_cp_function_context;
6280   free_lang_status = &pop_cp_function_context;
6281   mark_lang_status = &mark_cp_function_context;
6282
6283   cp_parse_init ();
6284   init_decl2 ();
6285   init_pt ();
6286
6287   /* Create the global variables.  */
6288   push_to_top_level ();
6289
6290   /* Enter the global namespace. */
6291   my_friendly_assert (global_namespace == NULL_TREE, 375);
6292   push_namespace (get_identifier ("::"));
6293   global_namespace = current_namespace;
6294   current_lang_name = NULL_TREE;
6295
6296   /* Adjust various flags based on command-line settings.  */
6297   if (! flag_permissive && ! pedantic)
6298     flag_pedantic_errors = 1;
6299   if (!flag_no_inline)
6300     flag_inline_trees = 1;
6301
6302   /* Initially, C.  */
6303   current_lang_name = lang_name_c;
6304
6305   current_function_decl = NULL_TREE;
6306   current_binding_level = NULL_BINDING_LEVEL;
6307   free_binding_level = NULL_BINDING_LEVEL;
6308
6309   build_common_tree_nodes (flag_signed_char);
6310
6311   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6312   TREE_TYPE (error_mark_list) = error_mark_node;
6313
6314   /* Make the binding_level structure for global names.  */
6315   pushlevel (0);
6316   global_binding_level = current_binding_level;
6317   /* The global level is the namespace level of ::.  */
6318   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6319   declare_namespace_level ();
6320
6321   /* Define `int' and `char' first so that dbx will output them first.  */
6322   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6323   record_builtin_type (RID_CHAR, "char", char_type_node);
6324
6325   /* `signed' is the same as `int' */
6326   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6327   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6328   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6329   record_builtin_type (CP_RID_MAX, "long unsigned int",
6330                        long_unsigned_type_node);
6331   record_builtin_type (CP_RID_MAX, "unsigned long", long_unsigned_type_node);
6332   record_builtin_type (CP_RID_MAX, "long long int",
6333                        long_long_integer_type_node);
6334   record_builtin_type (CP_RID_MAX, "long long unsigned int",
6335                        long_long_unsigned_type_node);
6336   record_builtin_type (CP_RID_MAX, "long long unsigned",
6337                        long_long_unsigned_type_node);
6338   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6339   record_builtin_type (CP_RID_MAX, "short unsigned int",
6340                        short_unsigned_type_node);
6341   record_builtin_type (CP_RID_MAX, "unsigned short",
6342                        short_unsigned_type_node);
6343
6344   ptrdiff_type_node
6345     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6346
6347   /* Define both `signed char' and `unsigned char'.  */
6348   record_builtin_type (CP_RID_MAX, "signed char", signed_char_type_node);
6349   record_builtin_type (CP_RID_MAX, "unsigned char", unsigned_char_type_node);
6350
6351   /* `unsigned long' is the standard type for sizeof.
6352      Note that stddef.h uses `unsigned long',
6353      and this must agree, even if long and int are the same size.  */
6354   set_sizetype
6355     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6356
6357   /* Create the widest literal types. */
6358   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6359   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6360                         widest_integer_literal_type_node));
6361
6362   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6363   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6364                         widest_unsigned_literal_type_node));
6365
6366   /* These are types that type_for_size and type_for_mode use.  */
6367   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6368   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6369   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6370   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6371 #if HOST_BITS_PER_WIDE_INT >= 64
6372   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6373 #endif
6374   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6375   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6376   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6377   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6378 #if HOST_BITS_PER_WIDE_INT >= 64
6379   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6380 #endif
6381
6382   build_common_tree_nodes_2 (flag_short_double);
6383
6384   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6385   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6386   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6387   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6388   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6389   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6390   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6391   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6392
6393   integer_two_node = build_int_2 (2, 0);
6394   TREE_TYPE (integer_two_node) = integer_type_node;
6395   integer_three_node = build_int_2 (3, 0);
6396   TREE_TYPE (integer_three_node) = integer_type_node;
6397
6398   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6399   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6400   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6401   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6402   TYPE_PRECISION (boolean_type_node) = 1;
6403   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6404   boolean_false_node = build_int_2 (0, 0);
6405   TREE_TYPE (boolean_false_node) = boolean_type_node;
6406   boolean_true_node = build_int_2 (1, 0);
6407   TREE_TYPE (boolean_true_node) = boolean_type_node;
6408
6409   signed_size_zero_node = build_int_2 (0, 0);
6410   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6411   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6412   record_builtin_type (CP_RID_MAX, "long double", long_double_type_node);
6413
6414   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6415                         complex_integer_type_node));
6416   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6417                         complex_float_type_node));
6418   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6419                         complex_double_type_node));
6420   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6421                         complex_long_double_type_node));
6422
6423   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6424
6425   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6426   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6427   TREE_PARMLIST (void_list_node) = 1;
6428
6429   /* Used for expressions that do nothing, but are not errors.  */
6430   void_zero_node = build_int_2 (0, 0);
6431   TREE_TYPE (void_zero_node) = void_type_node;
6432
6433   string_type_node = build_pointer_type (char_type_node);
6434   const_string_type_node
6435     = build_pointer_type (build_qualified_type (char_type_node,
6436                                                 TYPE_QUAL_CONST));
6437   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6438 #if 0
6439   record_builtin_type (CP_RID_MAX, NULL_PTR, string_type_node);
6440 #endif
6441
6442   /* Make a type to be the domain of a few array types
6443      whose domains don't really matter.
6444      200 is small enough that it always fits in size_t.  */
6445   array_domain_type = build_index_type (build_int_2 (200, 0));
6446
6447   /* Make a type for arrays of characters.
6448      With luck nothing will ever really depend on the length of this
6449      array type.  */
6450   char_array_type_node
6451     = build_array_type (char_type_node, array_domain_type);
6452
6453   /* Likewise for arrays of ints.  */
6454   int_array_type_node
6455     = build_array_type (integer_type_node, array_domain_type);
6456
6457   if (flag_new_abi)
6458     delta_type_node = ptrdiff_type_node;
6459   else if (flag_huge_objects)
6460     delta_type_node = long_integer_type_node;
6461   else
6462     delta_type_node = short_integer_type_node;
6463
6464   if (flag_new_abi)
6465     vtable_index_type = ptrdiff_type_node;
6466   else
6467     vtable_index_type = delta_type_node;
6468
6469   default_function_type
6470     = build_function_type (integer_type_node, NULL_TREE);
6471
6472   ptr_type_node = build_pointer_type (void_type_node);
6473   const_ptr_type_node
6474     = build_pointer_type (build_qualified_type (void_type_node,
6475                                                 TYPE_QUAL_CONST));
6476   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6477   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6478   lang_type_promotes_to = convert_type_from_ellipsis;
6479
6480   void_ftype_ptr
6481     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6482
6483   /* C++ extensions */
6484
6485   unknown_type_node = make_node (UNKNOWN_TYPE);
6486   record_unknown_type (unknown_type_node, "unknown type");
6487
6488   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6489   TREE_TYPE (unknown_type_node) = unknown_type_node;
6490
6491   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6492
6493   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6494      result.  */
6495   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6496   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6497
6498   /* This is special for C++ so functions can be overloaded.  */
6499   wchar_type_node = get_identifier (flag_short_wchar
6500                                     ? "short unsigned int"
6501                                     : WCHAR_TYPE);
6502   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6503   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6504   if (TREE_UNSIGNED (wchar_type_node))
6505     wchar_type_node = make_signed_type (wchar_type_size);
6506   else
6507     wchar_type_node = make_unsigned_type (wchar_type_size);
6508   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6509
6510   /* Artificial declaration of wchar_t -- can be bashed */
6511   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6512                                 wchar_type_node);
6513   pushdecl (wchar_decl_node);
6514
6515   /* This is for wide string constants.  */
6516   wchar_array_type_node
6517     = build_array_type (wchar_type_node, array_domain_type);
6518
6519   if (flag_vtable_thunks)
6520     {
6521       /* Make sure we get a unique function type, so we can give
6522          its pointer type a name.  (This wins for gdb.) */
6523       tree vfunc_type = make_node (FUNCTION_TYPE);
6524       TREE_TYPE (vfunc_type) = integer_type_node;
6525       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6526       layout_type (vfunc_type);
6527
6528       vtable_entry_type = build_pointer_type (vfunc_type);
6529     }
6530   else
6531     {
6532       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6533       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6534                               delta_type_node);
6535       fields[1] = build_decl (FIELD_DECL, index_identifier,
6536                               delta_type_node);
6537       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6538                               ptr_type_node);
6539       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6540                            double_type_node);
6541
6542       /* Make this part of an invisible union.  */
6543       fields[3] = copy_node (fields[2]);
6544       TREE_TYPE (fields[3]) = delta_type_node;
6545       DECL_NAME (fields[3]) = delta2_identifier;
6546       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6547       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6548       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6549       TREE_UNSIGNED (fields[3]) = 0;
6550       TREE_CHAIN (fields[2]) = fields[3];
6551       vtable_entry_type = build_qualified_type (vtable_entry_type,
6552                                                 TYPE_QUAL_CONST);
6553     }
6554   record_builtin_type (CP_RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6555
6556   vtbl_type_node
6557     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6558   layout_type (vtbl_type_node);
6559   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6560   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_type_node);
6561   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6562   layout_type (vtbl_ptr_type_node);
6563   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6564
6565   std_node = build_decl (NAMESPACE_DECL,
6566                          flag_honor_std
6567                          ? get_identifier ("fake std") : std_identifier,
6568                          void_type_node);
6569   pushdecl (std_node);
6570
6571   if (flag_new_abi)
6572     {
6573       push_namespace (get_identifier ("__cxxabiv1"));
6574       abi_node = current_namespace;
6575       pop_namespace ();
6576     }
6577
6578   global_type_node = make_node (LANG_TYPE);
6579   record_unknown_type (global_type_node, "global type");
6580
6581   /* Now, C++.  */
6582   current_lang_name = lang_name_cplusplus;
6583
6584   {
6585     tree bad_alloc_type_node, newtype, deltype;
6586     if (flag_honor_std)
6587       push_namespace (get_identifier ("std"));
6588     bad_alloc_type_node = xref_tag
6589       (class_type_node, get_identifier ("bad_alloc"), 1);
6590     if (flag_honor_std)
6591       pop_namespace ();
6592     newtype = build_exception_variant
6593       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6594     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6595     push_cp_library_fn (NEW_EXPR, newtype);
6596     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6597     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6598     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6599   }
6600
6601   abort_fndecl
6602     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6603
6604   /* Perform other language dependent initializations.  */
6605   init_class_processing ();
6606   init_init_processing ();
6607   init_search_processing ();
6608   init_rtti_processing ();
6609
6610   if (flag_exceptions)
6611     init_exception_processing ();
6612   if (flag_no_inline)
6613     {
6614       flag_inline_functions = 0;
6615     }
6616
6617   if (! supports_one_only ())
6618     flag_weak = 0;
6619
6620   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6621   make_fname_decl = cp_make_fname_decl;
6622   declare_function_name ();
6623
6624   /* Prepare to check format strings against argument lists.  */
6625   init_function_format_info ();
6626
6627   /* Show we use EH for cleanups.  */
6628   using_eh_for_cleanups ();
6629
6630   print_error_function = lang_print_error_function;
6631   valid_lang_attribute = cp_valid_lang_attribute;
6632
6633   /* Maintain consistency.  Perhaps we should just complain if they
6634      say -fwritable-strings?  */
6635   if (flag_writable_strings)
6636     flag_const_strings = 0;
6637
6638   /* Add GC roots for all of our global variables.  */
6639   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6640   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6641   ggc_add_tree_root (&integer_three_node, 1);
6642   ggc_add_tree_root (&integer_two_node, 1);
6643   ggc_add_tree_root (&signed_size_zero_node, 1);
6644   ggc_add_tree_root (&size_one_node, 1);
6645   ggc_add_tree_root (&size_zero_node, 1);
6646   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6647                 mark_binding_level);
6648   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6649   ggc_add_tree_root (&static_ctors, 1);
6650   ggc_add_tree_root (&static_dtors, 1);
6651   ggc_add_tree_root (&lastiddecl, 1);
6652
6653   ggc_add_tree_root (&last_function_parm_tags, 1);
6654   ggc_add_tree_root (&current_function_return_value, 1);
6655   ggc_add_tree_root (&current_function_parms, 1);
6656   ggc_add_tree_root (&current_function_parm_tags, 1);
6657   ggc_add_tree_root (&last_function_parms, 1);
6658   ggc_add_tree_root (&error_mark_list, 1);
6659
6660   ggc_add_tree_root (&global_namespace, 1);
6661   ggc_add_tree_root (&global_type_node, 1);
6662   ggc_add_tree_root (&anonymous_namespace_name, 1);
6663
6664   ggc_add_tree_root (&got_object, 1);
6665   ggc_add_tree_root (&got_scope, 1);
6666
6667   ggc_add_tree_root (&current_lang_name, 1);
6668   ggc_add_tree_root (&static_aggregates, 1);
6669 }
6670
6671 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6672    decl, NAME is the initialization string and TYPE_DEP indicates whether
6673    NAME depended on the type of the function. We make use of that to detect
6674    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6675    the function before emitting any of it, we don't need to treat the
6676    VAR_DECL specially. We can decide whether to emit it later, if it was
6677    used.  */
6678
6679 static tree
6680 cp_make_fname_decl (id, name, type_dep)
6681      tree id;
6682      const char *name;
6683      int type_dep;
6684 {
6685   tree decl, type, init;
6686   size_t length = strlen (name);
6687   tree domain = NULL_TREE;
6688
6689   if (!processing_template_decl)
6690     type_dep = 0;
6691   if (!type_dep)
6692     domain = build_index_type (build_int_2 (length, 0));
6693
6694   type =  build_cplus_array_type
6695           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6696            domain);
6697
6698   decl = build_decl (VAR_DECL, id, type);
6699   TREE_STATIC (decl) = 1;
6700   TREE_READONLY (decl) = 1;
6701   DECL_SOURCE_LINE (decl) = 0;
6702   DECL_ARTIFICIAL (decl) = 1;
6703   DECL_IN_SYSTEM_HEADER (decl) = 1;
6704   pushdecl (decl);
6705   if (processing_template_decl)
6706     decl = push_template_decl (decl);
6707   if (type_dep)
6708     {
6709       init = build (FUNCTION_NAME, type);
6710       DECL_PRETTY_FUNCTION_P (decl) = 1;
6711     }
6712   else
6713     {
6714       init = build_string (length + 1, name);
6715       TREE_TYPE (init) = type;
6716     }
6717   DECL_INITIAL (decl) = init;
6718   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6719
6720   /* We will have to make sure we only emit this, if it is actually used. */
6721   return decl;
6722 }
6723
6724 /* Function to print any language-specific context for an error message.  */
6725
6726 static void
6727 lang_print_error_function (file)
6728      const char *file;
6729 {
6730   default_print_error_function (file);
6731   maybe_print_template_context ();
6732 }
6733
6734 /* Entry point for the benefit of c_common_nodes_and_builtins.
6735
6736    Make a definition for a builtin function named NAME and whose data type
6737    is TYPE.  TYPE should be a function type with argument types.
6738
6739    CLASS and CODE tell later passes how to compile calls to this function.
6740    See tree.h for possible values.
6741
6742    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6743    the name to be called if we can't opencode the function.  */
6744
6745 tree
6746 builtin_function (name, type, code, class, libname)
6747      const char *name;
6748      tree type;
6749      int code;
6750      enum built_in_class class;
6751      const char *libname;
6752 {
6753   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6754   DECL_BUILT_IN_CLASS (decl) = class;
6755   DECL_FUNCTION_CODE (decl) = code;
6756
6757   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6758
6759   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6760      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6761      function in the namespace.  */
6762   pushdecl (decl);
6763   if (libname)
6764     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6765   make_function_rtl (decl);
6766
6767   /* Warn if a function in the namespace for users
6768      is used without an occasion to consider it declared.  */
6769   if (name[0] != '_' || name[1] != '_')
6770     DECL_ANTICIPATED (decl) = 1;
6771
6772   return decl;
6773 }
6774
6775 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6776    function.  Not called directly.  */
6777
6778 static tree
6779 build_library_fn_1 (name, operator_code, type)
6780      tree name;
6781      enum tree_code operator_code;
6782      tree type;
6783 {
6784   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6785   DECL_EXTERNAL (fn) = 1;
6786   TREE_PUBLIC (fn) = 1;
6787   DECL_ARTIFICIAL (fn) = 1;
6788   TREE_NOTHROW (fn) = 1;
6789   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6790   return fn;
6791 }
6792
6793 /* Returns the _DECL for a library function with C linkage.
6794    We assume that such functions never throw; if this is incorrect,
6795    callers should unset TREE_NOTHROW.  */
6796
6797 tree
6798 build_library_fn (name, type)
6799      tree name;
6800      tree type;
6801 {
6802   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6803   make_function_rtl (fn);
6804   return fn;
6805 }
6806
6807 /* Returns the _DECL for a library function with C++ linkage.  */
6808
6809 static tree
6810 build_cp_library_fn (name, operator_code, type)
6811      tree name;
6812      enum tree_code operator_code;
6813      tree type;
6814 {
6815   tree fn = build_library_fn_1 (name, operator_code, type);
6816   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6817   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6818   set_mangled_name_for_decl (fn);
6819   make_function_rtl (fn);
6820   return fn;
6821 }
6822
6823 /* Like build_library_fn, but takes a C string instead of an
6824    IDENTIFIER_NODE.  */
6825
6826 tree
6827 build_library_fn_ptr (name, type)
6828      const char *name;
6829      tree type;
6830 {
6831   return build_library_fn (get_identifier (name), type);
6832 }
6833
6834 /* Like build_cp_library_fn, but takes a C string instead of an
6835    IDENTIFIER_NODE.  */
6836
6837 tree
6838 build_cp_library_fn_ptr (name, type)
6839      const char *name;
6840      tree type;
6841 {
6842   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6843 }
6844
6845 /* Like build_library_fn, but also pushes the function so that we will
6846    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6847
6848 tree
6849 push_library_fn (name, type)
6850      tree name, type;
6851 {
6852   tree fn = build_library_fn (name, type);
6853   pushdecl_top_level (fn);
6854   return fn;
6855 }
6856
6857 /* Like build_cp_library_fn, but also pushes the function so that it
6858    will be found by normal lookup.  */
6859
6860 static tree
6861 push_cp_library_fn (operator_code, type)
6862      enum tree_code operator_code;
6863      tree type;
6864 {
6865   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6866                                  operator_code,
6867                                  type);
6868   pushdecl (fn);
6869   return fn;
6870 }
6871
6872 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6873    a FUNCTION_TYPE.  */
6874
6875 tree
6876 push_void_library_fn (name, parmtypes)
6877      tree name, parmtypes;
6878 {
6879   tree type = build_function_type (void_type_node, parmtypes);
6880   return push_library_fn (name, type);
6881 }
6882
6883 /* Like push_library_fn, but also note that this function throws
6884    and does not return.  Used for __throw_foo and the like.  */
6885
6886 tree
6887 push_throw_library_fn (name, type)
6888      tree name, type;
6889 {
6890   tree fn = push_library_fn (name, type);
6891   TREE_THIS_VOLATILE (fn) = 1;
6892   TREE_NOTHROW (fn) = 0;
6893   return fn;
6894 }
6895 \f
6896 /* When we call finish_struct for an anonymous union, we create
6897    default copy constructors and such.  But, an anonymous union
6898    shouldn't have such things; this function undoes the damage to the
6899    anonymous union type T.
6900
6901    (The reason that we create the synthesized methods is that we don't
6902    distinguish `union { int i; }' from `typedef union { int i; } U'.
6903    The first is an anonymous union; the second is just an ordinary
6904    union type.)  */
6905
6906 void
6907 fixup_anonymous_aggr (t)
6908      tree t;
6909 {
6910   tree *q;
6911
6912   /* Wipe out memory of synthesized methods */
6913   TYPE_HAS_CONSTRUCTOR (t) = 0;
6914   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6915   TYPE_HAS_INIT_REF (t) = 0;
6916   TYPE_HAS_CONST_INIT_REF (t) = 0;
6917   TYPE_HAS_ASSIGN_REF (t) = 0;
6918   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6919
6920   /* Splice the implicitly generated functions out of the TYPE_METHODS
6921      list.  */
6922   q = &TYPE_METHODS (t);
6923   while (*q)
6924     {
6925       if (DECL_ARTIFICIAL (*q))
6926         *q = TREE_CHAIN (*q);
6927       else
6928         q = &TREE_CHAIN (*q);
6929     }
6930
6931   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6932   if (TYPE_METHODS (t))
6933     error ("an anonymous union cannot have function members");
6934 }
6935
6936 /* Make sure that a declaration with no declarator is well-formed, i.e.
6937    just defines a tagged type or anonymous union.
6938
6939    Returns the type defined, if any.  */
6940
6941 tree
6942 check_tag_decl (declspecs)
6943      tree declspecs;
6944 {
6945   int found_type = 0;
6946   int saw_friend = 0;
6947   tree ob_modifier = NULL_TREE;
6948   register tree link;
6949   register tree t = NULL_TREE;
6950
6951   for (link = declspecs; link; link = TREE_CHAIN (link))
6952     {
6953       register tree value = TREE_VALUE (link);
6954
6955       if (TYPE_P (value)
6956           || (TREE_CODE (value) == IDENTIFIER_NODE
6957               && IDENTIFIER_GLOBAL_VALUE (value)
6958               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6959         {
6960           ++found_type;
6961
6962           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6963             {
6964               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6965               t = value;
6966             }
6967         }
6968       else if (value == ridpointers[(int) RID_FRIEND])
6969         {
6970           if (current_class_type == NULL_TREE
6971               || current_scope () != current_class_type)
6972             ob_modifier = value;
6973           else
6974             saw_friend = 1;
6975         }
6976       else if (value == ridpointers[(int) RID_STATIC]
6977                || value == ridpointers[(int) RID_EXTERN]
6978                || value == ridpointers[(int) RID_AUTO]
6979                || value == ridpointers[(int) RID_REGISTER]
6980                || value == ridpointers[(int) RID_INLINE]
6981                || value == ridpointers[(int) RID_VIRTUAL]
6982                || value == ridpointers[(int) RID_CONST]
6983                || value == ridpointers[(int) RID_VOLATILE]
6984                || value == ridpointers[(int) RID_EXPLICIT])
6985         ob_modifier = value;
6986     }
6987
6988   if (found_type > 1)
6989     error ("multiple types in one declaration");
6990
6991   if (t == NULL_TREE && ! saw_friend)
6992     pedwarn ("declaration does not declare anything");
6993
6994   /* Check for an anonymous union.  We're careful
6995      accessing TYPE_IDENTIFIER because some built-in types, like
6996      pointer-to-member types, do not have TYPE_NAME.  */
6997   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6998            && TYPE_NAME (t)
6999            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7000     {
7001       /* Anonymous unions are objects, so they can have specifiers.  */;
7002       SET_ANON_AGGR_TYPE_P (t);
7003
7004       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7005         pedwarn ("ISO C++ prohibits anonymous structs");
7006     }
7007
7008   else if (ob_modifier)
7009     {
7010       if (ob_modifier == ridpointers[(int) RID_INLINE]
7011           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7012         cp_error ("`%D' can only be specified for functions", ob_modifier);
7013       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7014         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7015       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7016         cp_error ("`%D' can only be specified for constructors",
7017                   ob_modifier);
7018       else
7019         cp_error ("`%D' can only be specified for objects and functions",
7020                   ob_modifier);
7021     }
7022
7023   return t;
7024 }
7025
7026 /* Called when a declaration is seen that contains no names to declare.
7027    If its type is a reference to a structure, union or enum inherited
7028    from a containing scope, shadow that tag name for the current scope
7029    with a forward reference.
7030    If its type defines a new named structure or union
7031    or defines an enum, it is valid but we need not do anything here.
7032    Otherwise, it is an error.
7033
7034    C++: may have to grok the declspecs to learn about static,
7035    complain for anonymous unions.  */
7036
7037 void
7038 shadow_tag (declspecs)
7039      tree declspecs;
7040 {
7041   tree t = check_tag_decl (declspecs);
7042
7043   if (t)
7044     maybe_process_partial_specialization (t);
7045
7046   /* This is where the variables in an anonymous union are
7047      declared.  An anonymous union declaration looks like:
7048      union { ... } ;
7049      because there is no declarator after the union, the parser
7050      sends that declaration here.  */
7051   if (t && ANON_AGGR_TYPE_P (t))
7052     {
7053       fixup_anonymous_aggr (t);
7054
7055       if (TYPE_FIELDS (t))
7056         {
7057           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7058                                       NULL_TREE);
7059           finish_anon_union (decl);
7060         }
7061     }
7062 }
7063 \f
7064 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7065
7066 tree
7067 groktypename (typename)
7068      tree typename;
7069 {
7070   if (TREE_CODE (typename) != TREE_LIST)
7071     return typename;
7072   return grokdeclarator (TREE_VALUE (typename),
7073                          TREE_PURPOSE (typename),
7074                          TYPENAME, 0, NULL_TREE);
7075 }
7076
7077 /* Decode a declarator in an ordinary declaration or data definition.
7078    This is called as soon as the type information and variable name
7079    have been parsed, before parsing the initializer if any.
7080    Here we create the ..._DECL node, fill in its type,
7081    and put it on the list of decls for the current context.
7082    The ..._DECL node is returned as the value.
7083
7084    Exception: for arrays where the length is not specified,
7085    the type is left null, to be filled in by `cp_finish_decl'.
7086
7087    Function definitions do not come here; they go to start_function
7088    instead.  However, external and forward declarations of functions
7089    do go through here.  Structure field declarations are done by
7090    grokfield and not through here.  */
7091
7092 tree
7093 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7094      tree declarator, declspecs;
7095      int initialized;
7096      tree attributes, prefix_attributes;
7097 {
7098   register tree decl;
7099   register tree type, tem;
7100   tree context;
7101   extern int have_extern_spec;
7102   extern int used_extern_spec;
7103   tree attrlist;
7104
7105 #if 0
7106   /* See code below that used this.  */
7107   int init_written = initialized;
7108 #endif
7109
7110   /* This should only be done once on the top most decl.  */
7111   if (have_extern_spec && !used_extern_spec)
7112     {
7113       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7114                                   declspecs);
7115       used_extern_spec = 1;
7116     }
7117
7118   if (attributes || prefix_attributes)
7119     attrlist = build_tree_list (attributes, prefix_attributes);
7120   else
7121     attrlist = NULL_TREE;
7122
7123   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7124                          attrlist);
7125
7126   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7127     return NULL_TREE;
7128
7129   type = TREE_TYPE (decl);
7130
7131   if (type == error_mark_node)
7132     return NULL_TREE;
7133
7134   context = DECL_CONTEXT (decl);
7135
7136   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7137       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7138     {
7139       /* When parsing the initializer, lookup should use the object's
7140          namespace. */
7141       push_decl_namespace (context);
7142     }
7143
7144   /* We are only interested in class contexts, later. */
7145   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7146     context = NULL_TREE;
7147
7148   if (initialized)
7149     /* Is it valid for this decl to have an initializer at all?
7150        If not, set INITIALIZED to zero, which will indirectly
7151        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7152     switch (TREE_CODE (decl))
7153       {
7154       case TYPE_DECL:
7155         /* typedef foo = bar  means give foo the same type as bar.
7156            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7157            Any other case of an initialization in a TYPE_DECL is an error.  */
7158         if (pedantic || list_length (declspecs) > 1)
7159           {
7160             cp_error ("typedef `%D' is initialized", decl);
7161             initialized = 0;
7162           }
7163         break;
7164
7165       case FUNCTION_DECL:
7166         cp_error ("function `%#D' is initialized like a variable", decl);
7167         initialized = 0;
7168         break;
7169
7170       default:
7171         break;
7172       }
7173
7174   if (initialized)
7175     {
7176       if (! toplevel_bindings_p ()
7177           && DECL_EXTERNAL (decl))
7178         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7179                     decl);
7180       DECL_EXTERNAL (decl) = 0;
7181       if (toplevel_bindings_p ())
7182         TREE_STATIC (decl) = 1;
7183
7184       /* Tell `pushdecl' this is an initialized decl
7185          even though we don't yet have the initializer expression.
7186          Also tell `cp_finish_decl' it may store the real initializer.  */
7187       DECL_INITIAL (decl) = error_mark_node;
7188     }
7189
7190 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7191   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7192 #endif
7193
7194   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7195   cplus_decl_attributes (decl, attributes, prefix_attributes);
7196
7197   if (context && COMPLETE_TYPE_P (complete_type (context)))
7198     {
7199       push_nested_class (context, 2);
7200
7201       if (TREE_CODE (decl) == VAR_DECL)
7202         {
7203           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7204           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7205             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7206           else
7207             {
7208               if (DECL_CONTEXT (field) != context)
7209                 {
7210                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7211                               DECL_CONTEXT (field), DECL_NAME (decl),
7212                               context, DECL_NAME (decl));
7213                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7214                 }
7215               /* Static data member are tricky; an in-class initialization
7216                  still doesn't provide a definition, so the in-class
7217                  declaration will have DECL_EXTERNAL set, but will have an
7218                  initialization.  Thus, duplicate_decls won't warn
7219                  about this situation, and so we check here.  */
7220               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7221                 cp_error ("duplicate initialization of %D", decl);
7222               if (duplicate_decls (decl, field))
7223                 decl = field;
7224             }
7225         }
7226       else
7227         {
7228           tree field = check_classfn (context, decl);
7229           if (field && duplicate_decls (decl, field))
7230             decl = field;
7231         }
7232
7233       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7234       DECL_IN_AGGR_P (decl) = 0;
7235       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7236           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7237         {
7238           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7239           /* [temp.expl.spec] An explicit specialization of a static data
7240              member of a template is a definition if the declaration
7241              includes an initializer; otherwise, it is a declaration.
7242
7243              We check for processing_specialization so this only applies
7244              to the new specialization syntax.  */
7245           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7246             DECL_EXTERNAL (decl) = 1;
7247         }
7248
7249       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7250         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7251                     decl);
7252     }
7253
7254   /* Enter this declaration into the symbol table.  */
7255   tem = maybe_push_decl (decl);
7256
7257   if (processing_template_decl)
7258     tem = push_template_decl (tem);
7259
7260 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7261   /* Tell the back-end to use or not use .common as appropriate.  If we say
7262      -fconserve-space, we want this to save .data space, at the expense of
7263      wrong semantics.  If we say -fno-conserve-space, we want this to
7264      produce errors about redefs; to do this we force variables into the
7265      data segment.  */
7266   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7267 #endif
7268
7269   if (! processing_template_decl)
7270     start_decl_1 (tem);
7271
7272   return tem;
7273 }
7274
7275 void
7276 start_decl_1 (decl)
7277      tree decl;
7278 {
7279   tree type = TREE_TYPE (decl);
7280   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7281
7282   if (type == error_mark_node)
7283     return;
7284
7285   /* If this type of object needs a cleanup, but we're not allowed to
7286      add any more objects with cleanups to the current scope, create a
7287      new binding level.  */
7288   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7289       && current_binding_level->more_cleanups_ok == 0)
7290     {
7291       keep_next_level (2);
7292       pushlevel (1);
7293       clear_last_expr ();
7294       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7295     }
7296
7297   if (initialized)
7298     /* Is it valid for this decl to have an initializer at all?
7299        If not, set INITIALIZED to zero, which will indirectly
7300        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7301     {
7302       /* Don't allow initializations for incomplete types except for
7303          arrays which might be completed by the initialization.  */
7304       if (COMPLETE_TYPE_P (complete_type (type)))
7305         ;                       /* A complete type is ok.  */
7306       else if (TREE_CODE (type) != ARRAY_TYPE)
7307         {
7308           cp_error ("variable `%#D' has initializer but incomplete type",
7309                     decl);
7310           initialized = 0;
7311           type = TREE_TYPE (decl) = error_mark_node;
7312         }
7313       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7314         {
7315           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7316             cp_error ("elements of array `%#D' have incomplete type", decl);
7317           /* else we already gave an error in start_decl.  */
7318           initialized = 0;
7319         }
7320     }
7321
7322   if (!initialized
7323       && TREE_CODE (decl) != TYPE_DECL
7324       && TREE_CODE (decl) != TEMPLATE_DECL
7325       && type != error_mark_node
7326       && IS_AGGR_TYPE (type)
7327       && ! DECL_EXTERNAL (decl))
7328     {
7329       if ((! processing_template_decl || ! uses_template_parms (type))
7330           && !COMPLETE_TYPE_P (complete_type (type)))
7331         {
7332           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7333                  decl);
7334           /* Change the type so that assemble_variable will give
7335              DECL an rtl we can live with: (mem (const_int 0)).  */
7336           type = TREE_TYPE (decl) = error_mark_node;
7337         }
7338       else
7339         {
7340           /* If any base type in the hierarchy of TYPE needs a constructor,
7341              then we set initialized to 1.  This way any nodes which are
7342              created for the purposes of initializing this aggregate
7343              will live as long as it does.  This is necessary for global
7344              aggregates which do not have their initializers processed until
7345              the end of the file.  */
7346           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7347         }
7348     }
7349
7350   if (! initialized)
7351     DECL_INITIAL (decl) = NULL_TREE;
7352 }
7353
7354 /* Handle initialization of references.
7355    These three arguments are from `cp_finish_decl', and have the
7356    same meaning here that they do there.
7357
7358    Quotes on semantics can be found in ARM 8.4.3.  */
7359
7360 static void
7361 grok_reference_init (decl, type, init)
7362      tree decl, type, init;
7363 {
7364   tree tmp;
7365
7366   if (init == NULL_TREE)
7367     {
7368       if ((DECL_LANG_SPECIFIC (decl) == 0
7369            || DECL_IN_AGGR_P (decl) == 0)
7370           && ! DECL_THIS_EXTERN (decl))
7371         cp_error ("`%D' declared as reference but not initialized", decl);
7372       return;
7373     }
7374
7375   if (init == error_mark_node)
7376     return;
7377
7378   if (TREE_CODE (init) == CONSTRUCTOR)
7379     {
7380       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7381       return;
7382     }
7383
7384   if (TREE_CODE (init) == TREE_LIST)
7385     init = build_compound_expr (init);
7386
7387   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7388     init = convert_from_reference (init);
7389
7390   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7391       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7392     {
7393       /* Note: default conversion is only called in very special cases.  */
7394       init = default_conversion (init);
7395     }
7396
7397   /* Convert INIT to the reference type TYPE.  This may involve the
7398      creation of a temporary, whose lifetime must be the same as that
7399      of the reference.  If so, a DECL_STMT for the temporary will be
7400      added just after the DECL_STMT for DECL.  That's why we don't set
7401      DECL_INITIAL for local references (instead assigning to them
7402      explicitly); we need to allow the temporary to be initialized
7403      first.  */
7404   tmp = convert_to_reference
7405     (type, init, CONV_IMPLICIT,
7406      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7407      decl);
7408
7409   if (tmp == error_mark_node)
7410     return;
7411   else if (tmp != NULL_TREE)
7412     {
7413       init = tmp;
7414       tmp = save_expr (tmp);
7415       if (building_stmt_tree ())
7416         {
7417           /* Initialize the declaration.  */
7418           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7419           finish_expr_stmt (tmp);
7420         }
7421       else
7422         DECL_INITIAL (decl) = tmp;
7423     }
7424   else
7425     {
7426       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7427       return;
7428     }
7429
7430   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7431     {
7432       expand_static_init (decl, DECL_INITIAL (decl));
7433       DECL_INITIAL (decl) = NULL_TREE;
7434     }
7435   return;
7436 }
7437
7438 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7439    mucking with forces it does not comprehend (i.e. initialization with a
7440    constructor).  If we are at global scope and won't go into COMMON, fill
7441    it in with a dummy CONSTRUCTOR to force the variable into .data;
7442    otherwise we can use error_mark_node.  */
7443
7444 static tree
7445 obscure_complex_init (decl, init)
7446      tree decl, init;
7447 {
7448   if (! flag_no_inline && TREE_STATIC (decl))
7449     {
7450       if (extract_init (decl, init))
7451         return NULL_TREE;
7452     }
7453
7454 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7455   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7456     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7457                                  NULL_TREE);
7458   else
7459 #endif
7460     DECL_INITIAL (decl) = error_mark_node;
7461
7462   return init;
7463 }
7464
7465 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7466    array until we finish parsing the initializer.  If that's the
7467    situation we're in, update DECL accordingly.  */
7468
7469 static void
7470 maybe_deduce_size_from_array_init (decl, init)
7471      tree decl;
7472      tree init;
7473 {
7474   tree type = TREE_TYPE (decl);
7475
7476   if (TREE_CODE (type) == ARRAY_TYPE
7477       && TYPE_DOMAIN (type) == NULL_TREE
7478       && TREE_CODE (decl) != TYPE_DECL)
7479     {
7480       int do_default
7481         = (TREE_STATIC (decl)
7482            /* Even if pedantic, an external linkage array
7483               may have incomplete type at first.  */
7484            ? pedantic && ! DECL_EXTERNAL (decl)
7485            : !DECL_EXTERNAL (decl));
7486       tree initializer = init ? init : DECL_INITIAL (decl);
7487       int failure = complete_array_type (type, initializer, do_default);
7488
7489       if (failure == 1)
7490         cp_error ("initializer fails to determine size of `%D'", decl);
7491
7492       if (failure == 2)
7493         {
7494           if (do_default)
7495             cp_error ("array size missing in `%D'", decl);
7496           /* If a `static' var's size isn't known, make it extern as
7497              well as static, so it does not get allocated.  If it's not
7498              `static', then don't mark it extern; finish_incomplete_decl
7499              will give it a default size and it will get allocated.  */
7500           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7501             DECL_EXTERNAL (decl) = 1;
7502         }
7503
7504       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7505           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7506                               integer_zero_node))
7507         cp_error ("zero-size array `%D'", decl);
7508
7509       layout_decl (decl, 0);
7510     }
7511 }
7512
7513 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7514    any appropriate error messages regarding the layout.  */
7515
7516 static void
7517 layout_var_decl (decl)
7518      tree decl;
7519 {
7520   tree type = TREE_TYPE (decl);
7521 #if 0
7522   tree ttype = target_type (type);
7523 #endif
7524
7525   /* If we haven't already layed out this declaration, do so now.
7526      Note that we must not call complete type for an external object
7527      because it's type might involve templates that we are not
7528      supposed to isntantiate yet.  (And it's perfectly legal to say
7529      `extern X x' for some incomplete type `X'.)  */
7530   if (!DECL_EXTERNAL (decl))
7531     complete_type (type);
7532   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7533     layout_decl (decl, 0);
7534
7535   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7536     {
7537       /* An automatic variable with an incomplete type: that is an error.
7538          Don't talk about array types here, since we took care of that
7539          message in grokdeclarator.  */
7540       cp_error ("storage size of `%D' isn't known", decl);
7541       TREE_TYPE (decl) = error_mark_node;
7542     }
7543 #if 0
7544   /* Keep this code around in case we later want to control debug info
7545      based on whether a type is "used".  (jason 1999-11-11) */
7546
7547   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7548     /* Let debugger know it should output info for this type.  */
7549     note_debug_info_needed (ttype);
7550
7551   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7552     note_debug_info_needed (DECL_CONTEXT (decl));
7553 #endif
7554
7555   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7556       && DECL_SIZE (decl) != NULL_TREE
7557       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7558     {
7559       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7560         constant_expression_warning (DECL_SIZE (decl));
7561       else
7562         cp_error ("storage size of `%D' isn't constant", decl);
7563     }
7564 }
7565
7566 /* If a local static variable is declared in an inline function, or if
7567    we have a weak definition, we must endeavor to create only one
7568    instance of the variable at link-time.  */
7569
7570 static void
7571 maybe_commonize_var (decl)
7572      tree decl;
7573 {
7574   /* Static data in a function with comdat linkage also has comdat
7575      linkage.  */
7576   if (TREE_STATIC (decl)
7577       /* Don't mess with __FUNCTION__.  */
7578       && ! DECL_ARTIFICIAL (decl)
7579       && current_function_decl
7580       && DECL_CONTEXT (decl) == current_function_decl
7581       && (DECL_THIS_INLINE (current_function_decl)
7582           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7583       && TREE_PUBLIC (current_function_decl))
7584     {
7585       /* Rather than try to get this right with inlining, we suppress
7586          inlining of such functions.  */
7587       current_function_cannot_inline
7588         = "function with static variable cannot be inline";
7589
7590       /* If flag_weak, we don't need to mess with this, as we can just
7591          make the function weak, and let it refer to its unique local
7592          copy.  This works because we don't allow the function to be
7593          inlined.  */
7594       if (! flag_weak)
7595         {
7596           if (DECL_INTERFACE_KNOWN (current_function_decl))
7597             {
7598               TREE_PUBLIC (decl) = 1;
7599               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7600             }
7601           else if (DECL_INITIAL (decl) == NULL_TREE
7602                    || DECL_INITIAL (decl) == error_mark_node)
7603             {
7604               TREE_PUBLIC (decl) = 1;
7605               DECL_COMMON (decl) = 1;
7606             }
7607           /* else we lose. We can only do this if we can use common,
7608              which we can't if it has been initialized.  */
7609
7610           if (TREE_PUBLIC (decl))
7611             DECL_ASSEMBLER_NAME (decl)
7612               = build_static_name (current_function_decl, DECL_NAME (decl));
7613           else
7614             {
7615               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7616               cp_warning_at ("  you can work around this by removing the initializer", decl);
7617             }
7618         }
7619     }
7620   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7621     /* Set it up again; we might have set DECL_INITIAL since the last
7622        time.  */
7623     comdat_linkage (decl);
7624 }
7625
7626 /* Issue an error message if DECL is an uninitialized const variable.  */
7627
7628 static void
7629 check_for_uninitialized_const_var (decl)
7630      tree decl;
7631 {
7632   tree type = TREE_TYPE (decl);
7633
7634   /* ``Unless explicitly declared extern, a const object does not have
7635      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7636      7.1.6 */
7637   if (TREE_CODE (decl) == VAR_DECL
7638       && TREE_CODE (type) != REFERENCE_TYPE
7639       && CP_TYPE_CONST_P (type)
7640       && !TYPE_NEEDS_CONSTRUCTING (type)
7641       && !DECL_INITIAL (decl))
7642     cp_error ("uninitialized const `%D'", decl);
7643 }
7644
7645 /* Verify INIT (the initializer for DECL), and record the
7646    initialization in DECL_INITIAL, if appropriate.  Returns a new
7647    value for INIT.  */
7648
7649 static tree
7650 check_initializer (decl, init)
7651      tree decl;
7652      tree init;
7653 {
7654   tree type;
7655
7656   if (TREE_CODE (decl) == FIELD_DECL)
7657     return init;
7658
7659   type = TREE_TYPE (decl);
7660
7661   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7662   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7663     init = NULL_TREE;
7664
7665   /* Check the initializer.  */
7666   if (init)
7667     {
7668       /* Things that are going to be initialized need to have complete
7669          type.  */
7670       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7671
7672       if (type == error_mark_node)
7673         /* We will have already complained.  */
7674         init = NULL_TREE;
7675       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7676         {
7677           cp_error ("variable-sized object `%D' may not be initialized", decl);
7678           init = NULL_TREE;
7679         }
7680       else if (TREE_CODE (type) == ARRAY_TYPE
7681                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7682         {
7683           cp_error ("elements of array `%#D' have incomplete type", decl);
7684           init = NULL_TREE;
7685         }
7686       else if (!COMPLETE_TYPE_P (type))
7687         {
7688           cp_error ("`%D' has incomplete type", decl);
7689           TREE_TYPE (decl) = error_mark_node;
7690           init = NULL_TREE;
7691         }
7692     }
7693
7694   if (TREE_CODE (decl) == CONST_DECL)
7695     {
7696       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7697
7698       DECL_INITIAL (decl) = init;
7699
7700       /* This will keep us from needing to worry about our obstacks.  */
7701       my_friendly_assert (init != NULL_TREE, 149);
7702       init = NULL_TREE;
7703     }
7704   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7705     {
7706       if (TREE_STATIC (decl))
7707         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7708       grok_reference_init (decl, type, init);
7709       init = NULL_TREE;
7710     }
7711   else if (init)
7712     {
7713       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7714         {
7715           if (TREE_CODE (type) == ARRAY_TYPE)
7716             init = digest_init (type, init, (tree *) 0);
7717           else if (TREE_CODE (init) == CONSTRUCTOR
7718                    && TREE_HAS_CONSTRUCTOR (init))
7719             {
7720               if (TYPE_NON_AGGREGATE_CLASS (type))
7721                 {
7722                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7723                             decl);
7724                   init = error_mark_node;
7725                 }
7726               else
7727                 goto dont_use_constructor;
7728             }
7729         }
7730       else
7731         {
7732         dont_use_constructor:
7733           if (TREE_CODE (init) != TREE_VEC)
7734             init = store_init_value (decl, init);
7735         }
7736
7737       if (init)
7738         /* We must hide the initializer so that expand_decl
7739            won't try to do something it does not understand.  */
7740         init = obscure_complex_init (decl, init);
7741     }
7742   else if (DECL_EXTERNAL (decl))
7743     ;
7744   else if (TYPE_P (type)
7745            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7746     {
7747       tree core_type = strip_array_types (type);
7748
7749       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7750         {
7751           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7752             cp_error ("structure `%D' with uninitialized const members", decl);
7753           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7754             cp_error ("structure `%D' with uninitialized reference members",
7755                       decl);
7756         }
7757
7758       check_for_uninitialized_const_var (decl);
7759
7760       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7761         init = obscure_complex_init (decl, NULL_TREE);
7762
7763     }
7764   else
7765     check_for_uninitialized_const_var (decl);
7766
7767   return init;
7768 }
7769
7770 /* If DECL is not a local variable, give it RTL.  */
7771
7772 static void
7773 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7774      tree decl;
7775      tree init;
7776      const char *asmspec;
7777 {
7778   int toplev = toplevel_bindings_p ();
7779   int defer_p;
7780
7781   /* Handle non-variables up front.  */
7782   if (TREE_CODE (decl) != VAR_DECL)
7783     {
7784       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7785       return;
7786     }
7787
7788   /* If we see a class member here, it should be a static data
7789      member.  */
7790   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7791     {
7792       my_friendly_assert (TREE_STATIC (decl), 19990828);
7793       /* An in-class declaration of a static data member should be
7794          external; it is only a declaration, and not a definition.  */
7795       if (init == NULL_TREE)
7796         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7797     }
7798
7799   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7800   if (asmspec)
7801     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7802
7803   /* We don't create any RTL for local variables.  */
7804   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7805     return;
7806
7807   /* We defer emission of local statics until the corresponding
7808      DECL_STMT is expanded.  */
7809   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7810
7811   /* We try to defer namespace-scope static constants so that they are
7812      not emitted into the object file unncessarily.  */
7813   if (!DECL_VIRTUAL_P (decl)
7814       && TREE_READONLY (decl)
7815       && DECL_INITIAL (decl) != NULL_TREE
7816       && DECL_INITIAL (decl) != error_mark_node
7817       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7818       && toplev
7819       && !TREE_PUBLIC (decl))
7820     {
7821       /* Fool with the linkage according to #pragma interface.  */
7822       if (!interface_unknown)
7823         {
7824           TREE_PUBLIC (decl) = 1;
7825           DECL_EXTERNAL (decl) = interface_only;
7826         }
7827
7828       defer_p = 1;
7829     }
7830
7831   /* If we're deferring the variable, just make RTL.  Do not actually
7832      emit the variable.  */
7833   if (defer_p)
7834     make_decl_rtl (decl, asmspec, toplev);
7835   /* If we're not deferring, go ahead and assemble the variable.  */
7836   else
7837     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7838 }
7839
7840 /* The old ARM scoping rules injected variables declared in the
7841    initialization statement of a for-statement into the surrounding
7842    scope.  We support this usage, in order to be backward-compatible.
7843    DECL is a just-declared VAR_DECL; if necessary inject its
7844    declaration into the surrounding scope.  */
7845
7846 void
7847 maybe_inject_for_scope_var (decl)
7848      tree decl;
7849 {
7850   if (!DECL_NAME (decl))
7851     return;
7852
7853   if (current_binding_level->is_for_scope)
7854     {
7855       struct binding_level *outer
7856         = current_binding_level->level_chain;
7857
7858       /* Check to see if the same name is already bound at the outer
7859          level, either because it was directly declared, or because a
7860          dead for-decl got preserved.  In either case, the code would
7861          not have been valid under the ARM scope rules, so clear
7862          is_for_scope for the current_binding_level.
7863
7864          Otherwise, we need to preserve the temp slot for decl to last
7865          into the outer binding level.  */
7866
7867       tree outer_binding
7868         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7869
7870       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7871           && (TREE_CODE (BINDING_VALUE (outer_binding))
7872               == VAR_DECL)
7873           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7874         {
7875           BINDING_VALUE (outer_binding)
7876             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7877           current_binding_level->is_for_scope = 0;
7878         }
7879       else if (DECL_IN_MEMORY_P (decl))
7880         preserve_temp_slots (DECL_RTL (decl));
7881     }
7882 }
7883
7884 /* Generate code to initialize DECL (a local variable).  */
7885
7886 void
7887 initialize_local_var (decl, init, flags)
7888      tree decl;
7889      tree init;
7890      int flags;
7891 {
7892   tree type = TREE_TYPE (decl);
7893
7894   /* If the type is bogus, don't bother initializing the variable.  */
7895   if (type == error_mark_node)
7896     return;
7897
7898   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7899     {
7900       /* If we used it already as memory, it must stay in memory.  */
7901       DECL_INITIAL (decl) = NULL_TREE;
7902       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7903     }
7904
7905   /* Local statics are handled differently from ordinary automatic
7906      variables.  */
7907   if (TREE_STATIC (decl))
7908     {
7909       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7910           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7911         expand_static_init (decl, init);
7912       return;
7913     }
7914
7915   if (DECL_SIZE (decl) && type != error_mark_node)
7916     {
7917       int already_used;
7918
7919       /* Compute and store the initial value.  */
7920       already_used = TREE_USED (decl) || TREE_USED (type);
7921
7922       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7923         {
7924           int saved_stmts_are_full_exprs_p;
7925
7926           emit_line_note (DECL_SOURCE_FILE (decl),
7927                           DECL_SOURCE_LINE (decl));
7928           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7929           current_stmt_tree->stmts_are_full_exprs_p = 1;
7930           if (building_stmt_tree ())
7931             finish_expr_stmt (build_aggr_init (decl, init, flags));
7932           else
7933             genrtl_expr_stmt (build_aggr_init (decl, init, flags));
7934           current_stmt_tree->stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7935         }
7936
7937       /* Set this to 0 so we can tell whether an aggregate which was
7938          initialized was ever used.  Don't do this if it has a
7939          destructor, so we don't complain about the 'resource
7940          allocation is initialization' idiom.  Now set
7941          attribute((unused)) on types so decls of that type will be
7942          marked used. (see TREE_USED, above.)  */
7943       if (TYPE_NEEDS_CONSTRUCTING (type)
7944           && ! already_used
7945           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7946           && DECL_NAME (decl))
7947         TREE_USED (decl) = 0;
7948       else if (already_used)
7949         TREE_USED (decl) = 1;
7950     }
7951 }
7952
7953 /* Generate code to destroy DECL (a local variable).  */
7954
7955 static void
7956 destroy_local_var (decl)
7957      tree decl;
7958 {
7959   tree type = TREE_TYPE (decl);
7960   tree cleanup;
7961
7962   /* Only variables get cleaned up.  */
7963   if (TREE_CODE (decl) != VAR_DECL)
7964     return;
7965
7966   /* And only things with destructors need cleaning up.  */
7967   if (type == error_mark_node
7968       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7969     return;
7970
7971   if (TREE_CODE (decl) == VAR_DECL &&
7972       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7973     /* We don't clean up things that aren't defined in this
7974        translation unit, or that need a static cleanup.  The latter
7975        are handled by finish_file.  */
7976     return;
7977
7978   /* Compute the cleanup.  */
7979   cleanup = maybe_build_cleanup (decl);
7980
7981   /* Record the cleanup required for this declaration.  */
7982   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7983       && cleanup)
7984     finish_decl_cleanup (decl, cleanup);
7985 }
7986
7987 /* Finish processing of a declaration;
7988    install its line number and initial value.
7989    If the length of an array type is not known before,
7990    it must be determined now, from the initial value, or it is an error.
7991
7992    INIT holds the value of an initializer that should be allowed to escape
7993    the normal rules.
7994
7995    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7996    if the (init) syntax was used.  */
7997
7998 void
7999 cp_finish_decl (decl, init, asmspec_tree, flags)
8000      tree decl, init;
8001      tree asmspec_tree;
8002      int flags;
8003 {
8004   register tree type;
8005   tree ttype = NULL_TREE;
8006   const char *asmspec = NULL;
8007   int was_readonly = 0;
8008
8009   if (! decl)
8010     {
8011       if (init)
8012         error ("assignment (not initialization) in declaration");
8013       return;
8014     }
8015
8016   /* If a name was specified, get the string.  */
8017   if (asmspec_tree)
8018       asmspec = TREE_STRING_POINTER (asmspec_tree);
8019
8020   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8021     {
8022       cp_error ("cannot initialize `%D' to namespace `%D'",
8023                 decl, init);
8024       init = NULL_TREE;
8025     }
8026
8027   if (current_class_type
8028       && CP_DECL_CONTEXT (decl) == current_class_type
8029       && TYPE_BEING_DEFINED (current_class_type)
8030       && (DECL_INITIAL (decl) || init))
8031     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8032
8033   if (TREE_CODE (decl) == VAR_DECL
8034       && DECL_CONTEXT (decl)
8035       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8036       && DECL_CONTEXT (decl) != current_namespace
8037       && init)
8038     {
8039       /* Leave the namespace of the object. */
8040       pop_decl_namespace ();
8041     }
8042
8043   type = TREE_TYPE (decl);
8044
8045   if (type == error_mark_node)
8046     return;
8047
8048   /* Add this declaration to the statement-tree.  */
8049   if (building_stmt_tree () && at_function_scope_p ())
8050     add_decl_stmt (decl);
8051
8052   if (TYPE_HAS_MUTABLE_P (type))
8053     TREE_READONLY (decl) = 0;
8054
8055   if (processing_template_decl)
8056     {
8057       if (init && DECL_INITIAL (decl))
8058         DECL_INITIAL (decl) = init;
8059       goto finish_end0;
8060     }
8061
8062   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8063   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8064
8065   /* Take care of TYPE_DECLs up front.  */
8066   if (TREE_CODE (decl) == TYPE_DECL)
8067     {
8068       if (init && DECL_INITIAL (decl))
8069         {
8070           /* typedef foo = bar; store the type of bar as the type of foo.  */
8071           TREE_TYPE (decl) = type = TREE_TYPE (init);
8072           DECL_INITIAL (decl) = init = NULL_TREE;
8073         }
8074       if (type != error_mark_node
8075           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8076         {
8077           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8078             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8079           set_identifier_type_value (DECL_NAME (decl), type);
8080           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8081         }
8082       GNU_xref_decl (current_function_decl, decl);
8083
8084       /* If we have installed this as the canonical typedef for this
8085          type, and that type has not been defined yet, delay emitting
8086          the debug information for it, as we will emit it later.  */
8087       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8088           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8089         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8090
8091       rest_of_decl_compilation (decl, NULL_PTR,
8092                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8093       goto finish_end;
8094     }
8095
8096   if (TREE_CODE (decl) != FUNCTION_DECL)
8097     ttype = target_type (type);
8098
8099   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8100       && TYPE_NEEDS_CONSTRUCTING (type))
8101     {
8102       /* Currently, GNU C++ puts constants in text space, making them
8103          impossible to initialize.  In the future, one would hope for
8104          an operating system which understood the difference between
8105          initialization and the running of a program.  */
8106       was_readonly = 1;
8107       TREE_READONLY (decl) = 0;
8108     }
8109
8110   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8111     {
8112       /* This must override the asm specifier which was placed by
8113          grokclassfn.  Lay this out fresh.  */
8114       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8115       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8116       make_decl_rtl (decl, asmspec, 0);
8117     }
8118
8119   /* Deduce size of array from initialization, if not already known.  */
8120   maybe_deduce_size_from_array_init (decl, init);
8121   init = check_initializer (decl, init);
8122
8123   GNU_xref_decl (current_function_decl, decl);
8124
8125   if (TREE_CODE (decl) == VAR_DECL)
8126     layout_var_decl (decl);
8127
8128   /* Output the assembler code and/or RTL code for variables and functions,
8129      unless the type is an undefined structure or union.
8130      If not, it will get done when the type is completed.  */
8131   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8132       || TREE_CODE (decl) == RESULT_DECL)
8133     {
8134       if (TREE_CODE (decl) == VAR_DECL)
8135         maybe_commonize_var (decl);
8136
8137       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8138
8139       if (TREE_CODE (type) == FUNCTION_TYPE
8140           || TREE_CODE (type) == METHOD_TYPE)
8141         abstract_virtuals_error (decl,
8142                                  strip_array_types (TREE_TYPE (type)));
8143       else
8144         abstract_virtuals_error (decl, strip_array_types (type));
8145
8146       if (TREE_CODE (decl) == FUNCTION_DECL)
8147         ;
8148       else if (DECL_EXTERNAL (decl)
8149                && ! (DECL_LANG_SPECIFIC (decl)
8150                      && DECL_NOT_REALLY_EXTERN (decl)))
8151         {
8152           if (init)
8153             DECL_INITIAL (decl) = init;
8154         }
8155       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8156         {
8157           /* This is a local declaration.  */
8158           if (doing_semantic_analysis_p ())
8159             maybe_inject_for_scope_var (decl);
8160           /* Initialize the local variable.  But, if we're building a
8161              statement-tree, we'll do the initialization when we
8162              expand the tree.  */
8163           if (processing_template_decl)
8164             {
8165               if (init || DECL_INITIAL (decl) == error_mark_node)
8166                 DECL_INITIAL (decl) = init;
8167             }
8168           else
8169             {
8170               /* If we're not building RTL, then we need to do so
8171                  now.  */
8172               if (!building_stmt_tree ())
8173                 emit_local_var (decl);
8174               /* Initialize the variable.  */
8175               initialize_local_var (decl, init, flags);
8176               /* Clean up the variable.  */
8177               destroy_local_var (decl);
8178             }
8179         }
8180       else if (TREE_STATIC (decl) && type != error_mark_node)
8181         {
8182           /* Cleanups for static variables are handled by `finish_file'.  */
8183           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8184               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8185             expand_static_init (decl, init);
8186         }
8187     finish_end0:
8188
8189       /* Undo call to `pushclass' that was done in `start_decl'
8190          due to initialization of qualified member variable.
8191          I.e., Foo::x = 10;  */
8192       {
8193         tree context = CP_DECL_CONTEXT (decl);
8194         if (context
8195             && TYPE_P (context)
8196             && (TREE_CODE (decl) == VAR_DECL
8197                 /* We also have a pushclass done that we need to undo here
8198                    if we're at top level and declare a method.  */
8199                 || TREE_CODE (decl) == FUNCTION_DECL)
8200             /* If size hasn't been set, we're still defining it,
8201                and therefore inside the class body; don't pop
8202                the binding level..  */
8203             && COMPLETE_TYPE_P (context)
8204             && context == current_class_type)
8205           pop_nested_class ();
8206       }
8207     }
8208
8209  finish_end:
8210
8211   if (was_readonly)
8212     TREE_READONLY (decl) = 1;
8213 }
8214
8215 /* This is here for a midend callback from c-common.c */
8216
8217 void
8218 finish_decl (decl, init, asmspec_tree)
8219      tree decl, init;
8220      tree asmspec_tree;
8221 {
8222   cp_finish_decl (decl, init, asmspec_tree, 0);
8223 }
8224
8225 /* Returns a declaration for a VAR_DECL as if:
8226
8227      extern "C" TYPE NAME;
8228
8229    had been seen.  Used to create compiler-generated global
8230    variables.  */
8231
8232 tree
8233 declare_global_var (name, type)
8234      tree name;
8235      tree type;
8236 {
8237   tree decl;
8238
8239   push_to_top_level ();
8240   decl = build_decl (VAR_DECL, name, type);
8241   TREE_PUBLIC (decl) = 1;
8242   DECL_EXTERNAL (decl) = 1;
8243   DECL_ARTIFICIAL (decl) = 1;
8244   pushdecl (decl);
8245   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8246   pop_from_top_level ();
8247
8248   return decl;
8249 }
8250
8251 /* Returns a pointer to the `atexit' function.  Note that if
8252    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8253    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8254
8255 static tree
8256 get_atexit_node ()
8257 {
8258   tree atexit_fndecl;
8259   tree arg_types;
8260   tree fn_type;
8261   tree fn_ptr_type;
8262   const char *name;
8263
8264   if (atexit_node)
8265     return atexit_node;
8266
8267   if (flag_use_cxa_atexit)
8268     {
8269       /* The declaration for `__cxa_atexit' is:
8270
8271            int __cxa_atexit (void (*)(void *), void *, void *)
8272
8273          We build up the argument types and then then function type
8274          itself.  */
8275
8276       /* First, build the pointer-to-function type for the first
8277          argument.  */
8278       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8279       fn_type = build_function_type (void_type_node, arg_types);
8280       fn_ptr_type = build_pointer_type (fn_type);
8281       /* Then, build the rest of the argument types.  */
8282       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8283       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8284       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8285       /* And the final __cxa_atexit type.  */
8286       fn_type = build_function_type (integer_type_node, arg_types);
8287       fn_ptr_type = build_pointer_type (fn_type);
8288       name = "__cxa_atexit";
8289     }
8290   else
8291     {
8292       /* The declaration for `atexit' is:
8293
8294            int atexit (void (*)());
8295
8296          We build up the argument types and then then function type
8297          itself.  */
8298       fn_type = build_function_type (void_type_node, void_list_node);
8299       fn_ptr_type = build_pointer_type (fn_type);
8300       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8301       /* Build the final atexit type.  */
8302       fn_type = build_function_type (integer_type_node, arg_types);
8303       name = "atexit";
8304     }
8305
8306   /* Now, build the function declaration.  */
8307   push_lang_context (lang_name_c);
8308   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8309   mark_used (atexit_fndecl);
8310   pop_lang_context ();
8311   atexit_node = default_conversion (atexit_fndecl);
8312
8313   return atexit_node;
8314 }
8315
8316 /* Returns the __dso_handle VAR_DECL.  */
8317
8318 static tree
8319 get_dso_handle_node ()
8320 {
8321   if (dso_handle_node)
8322     return dso_handle_node;
8323
8324   /* Declare the variable.  */
8325   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8326                                         ptr_type_node);
8327
8328   return dso_handle_node;
8329 }
8330
8331 /* Begin a new function with internal linkage whose job will be simply
8332    to destroy some particular variable.  */
8333
8334 static tree
8335 start_cleanup_fn ()
8336 {
8337   static int counter = 0;
8338   int old_interface_unknown = interface_unknown;
8339   char name[32];
8340   tree parmtypes;
8341   tree fntype;
8342   tree fndecl;
8343
8344   push_to_top_level ();
8345
8346   /* No need to mangle this.  */
8347   push_lang_context (lang_name_c);
8348
8349   interface_unknown = 1;
8350
8351   /* Build the parameter-types.  */
8352   parmtypes = void_list_node;
8353   /* Functions passed to __cxa_atexit take an additional parameter.
8354      We'll just ignore it.  After we implement the new calling
8355      convention for destructors, we can eliminate the use of
8356      additional cleanup functions entirely in the -fnew-abi case.  */
8357   if (flag_use_cxa_atexit)
8358     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8359   /* Build the function type itself.  */
8360   fntype = build_function_type (void_type_node, parmtypes);
8361   /* Build the name of the function.  */
8362   sprintf (name, "__tcf_%d", counter++);
8363   /* Build the function declaration.  */
8364   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8365   /* It's a function with internal linkage, generated by the
8366      compiler.  */
8367   TREE_PUBLIC (fndecl) = 0;
8368   DECL_ARTIFICIAL (fndecl) = 1;
8369   /* Make the function `inline' so that it is only emitted if it is
8370      actually needed.  It is unlikely that it will be inlined, since
8371      it is only called via a function pointer, but we avoid unncessary
8372      emissions this way.  */
8373   DECL_INLINE (fndecl) = 1;
8374   /* Build the parameter.  */
8375   if (flag_use_cxa_atexit)
8376     {
8377       tree parmdecl;
8378
8379       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8380       DECL_CONTEXT (parmdecl) = fndecl;
8381       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8382       TREE_USED (parmdecl) = 1;
8383       DECL_ARGUMENTS (fndecl) = parmdecl;
8384     }
8385
8386   pushdecl (fndecl);
8387   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8388   do_pushlevel ();
8389
8390   interface_unknown = old_interface_unknown;
8391
8392   pop_lang_context ();
8393
8394   return current_function_decl;
8395 }
8396
8397 /* Finish the cleanup function begun by start_cleanup_fn.  */
8398
8399 static void
8400 end_cleanup_fn ()
8401 {
8402   do_poplevel ();
8403
8404   expand_body (finish_function (0));
8405
8406   pop_from_top_level ();
8407 }
8408
8409 /* Generate code to handle the destruction of DECL, an object with
8410    static storage duration.  */
8411
8412 void
8413 register_dtor_fn (decl)
8414      tree decl;
8415 {
8416   tree cleanup;
8417   tree compound_stmt;
8418   tree args;
8419   tree fcall;
8420
8421   int saved_flag_access_control;
8422
8423   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8424     return;
8425
8426   /* Call build_cleanup before we enter the anonymous function so that
8427      any access checks will be done relative to the current scope,
8428      rather than the scope of the anonymous function.  */
8429   build_cleanup (decl);
8430
8431   /* Now start the function.  */
8432   cleanup = start_cleanup_fn ();
8433
8434   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8435      to the original function, rather than the anonymous one.  That
8436      will make the back-end think that nested functions are in use,
8437      which causes confusion.  */
8438   saved_flag_access_control = flag_access_control;
8439   flag_access_control = 0;
8440   fcall = build_cleanup (decl);
8441   flag_access_control = saved_flag_access_control;
8442
8443   /* Create the body of the anonymous function.  */
8444   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8445   finish_expr_stmt (fcall);
8446   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8447   end_cleanup_fn ();
8448
8449   /* Call atexit with the cleanup function.  */
8450   mark_addressable (cleanup);
8451   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8452   if (flag_use_cxa_atexit)
8453     {
8454       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8455       args = tree_cons (NULL_TREE, null_pointer_node, args);
8456       args = tree_cons (NULL_TREE, cleanup, args);
8457     }
8458   else
8459     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8460   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8461 }
8462
8463 void
8464 expand_static_init (decl, init)
8465      tree decl;
8466      tree init;
8467 {
8468   tree oldstatic = value_member (decl, static_aggregates);
8469
8470   if (oldstatic)
8471     {
8472       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8473         cp_error ("multiple initializations given for `%D'", decl);
8474     }
8475   else if (! toplevel_bindings_p ())
8476     {
8477       /* Emit code to perform this initialization but once.  */
8478       tree if_stmt;
8479       tree then_clause;
8480       tree assignment;
8481       tree guard;
8482       tree guard_init;
8483
8484       /* Emit code to perform this initialization but once.  This code
8485          looks like:
8486
8487            static int guard = 0;
8488            if (!guard) {
8489              // Do initialization.
8490              guard = 1;
8491              // Register variable for destruction at end of program.
8492            }
8493
8494          Note that the `temp' variable is only set to 1 *after* the
8495          initialization is complete.  This ensures that an exception,
8496          thrown during the construction, will cause the variable to
8497          reinitialized when we pass through this code again, as per:
8498
8499            [stmt.dcl]
8500
8501            If the initialization exits by throwing an exception, the
8502            initialization is not complete, so it will be tried again
8503            the next time control enters the declaration.
8504
8505          In theory, this process should be thread-safe, too; multiple
8506          threads should not be able to initialize the variable more
8507          than once.  We don't yet attempt to ensure thread-safety.  */
8508
8509       /* Create the guard variable.  */
8510       guard = get_guard (decl);
8511
8512       /* Begin the conditional initialization.  */
8513       if_stmt = begin_if_stmt ();
8514       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8515       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8516
8517       /* Do the initialization itself.  */
8518       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8519           || (init && TREE_CODE (init) == TREE_LIST))
8520         assignment = build_aggr_init (decl, init, 0);
8521       else if (init)
8522         /* The initialization we're doing here is just a bitwise
8523            copy.  */
8524         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8525       else
8526         assignment = NULL_TREE;
8527
8528       /* Once the assignment is complete, set TEMP to 1.  Since the
8529          construction of the static object is complete at this point,
8530          we want to make sure TEMP is set to 1 even if a temporary
8531          constructed during the initialization throws an exception
8532          when it is destroyed.  So, we combine the initialization and
8533          the assignment to TEMP into a single expression, ensuring
8534          that when we call finish_expr_stmt the cleanups will not be
8535          run until after TEMP is set to 1.  */
8536       guard_init = set_guard (guard);
8537       if (assignment)
8538         {
8539           assignment = tree_cons (NULL_TREE, assignment,
8540                                   build_tree_list (NULL_TREE,
8541                                                    guard_init));
8542           assignment = build_compound_expr (assignment);
8543         }
8544       else
8545         assignment = guard_init;
8546       finish_expr_stmt (assignment);
8547
8548       /* Use atexit to register a function for destroying this static
8549          variable.  */
8550       register_dtor_fn (decl);
8551
8552       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8553       finish_then_clause (if_stmt);
8554       finish_if_stmt ();
8555     }
8556   else
8557     static_aggregates = tree_cons (init, decl, static_aggregates);
8558 }
8559
8560 /* Finish the declaration of a catch-parameter.  */
8561
8562 tree
8563 start_handler_parms (declspecs, declarator)
8564      tree declspecs;
8565      tree declarator;
8566 {
8567   tree decl;
8568   if (declspecs)
8569     {
8570       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8571                              1, NULL_TREE);
8572       if (decl == NULL_TREE)
8573         error ("invalid catch parameter");
8574     }
8575   else
8576     decl = NULL_TREE;
8577
8578   return decl;
8579 }
8580
8581 \f
8582 /* Make TYPE a complete type based on INITIAL_VALUE.
8583    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8584    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8585
8586 int
8587 complete_array_type (type, initial_value, do_default)
8588      tree type, initial_value;
8589      int do_default;
8590 {
8591   register tree maxindex = NULL_TREE;
8592   int value = 0;
8593
8594   if (initial_value)
8595     {
8596       /* An array of character type can be initialized from a
8597          brace-enclosed string constant.  */
8598       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8599           && TREE_CODE (initial_value) == CONSTRUCTOR
8600           && CONSTRUCTOR_ELTS (initial_value)
8601           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8602               == STRING_CST)
8603           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8604         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8605
8606       /* Note MAXINDEX is really the maximum index, one less than the
8607          size.  */
8608       if (TREE_CODE (initial_value) == STRING_CST)
8609         {
8610           int eltsize
8611             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8612           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8613                                    / eltsize) - 1, 0);
8614         }
8615       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8616         {
8617           tree elts = CONSTRUCTOR_ELTS (initial_value);
8618
8619           maxindex = ssize_int (-1);
8620           for (; elts; elts = TREE_CHAIN (elts))
8621             {
8622               if (TREE_PURPOSE (elts))
8623                 maxindex = TREE_PURPOSE (elts);
8624               else
8625                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8626             }
8627           maxindex = copy_node (maxindex);
8628         }
8629       else
8630         {
8631           /* Make an error message unless that happened already.  */
8632           if (initial_value != error_mark_node)
8633             value = 1;
8634           else
8635             initial_value = NULL_TREE;
8636
8637           /* Prevent further error messages.  */
8638           maxindex = build_int_2 (0, 0);
8639         }
8640     }
8641
8642   if (!maxindex)
8643     {
8644       if (do_default)
8645         maxindex = build_int_2 (0, 0);
8646       value = 2;
8647     }
8648
8649   if (maxindex)
8650     {
8651       tree itype;
8652       tree domain;
8653
8654       domain = build_index_type (maxindex);
8655       TYPE_DOMAIN (type) = domain;
8656
8657       if (! TREE_TYPE (maxindex))
8658         TREE_TYPE (maxindex) = domain;
8659       if (initial_value)
8660         itype = TREE_TYPE (initial_value);
8661       else
8662         itype = NULL;
8663       if (itype && !TYPE_DOMAIN (itype))
8664         TYPE_DOMAIN (itype) = domain;
8665       /* The type of the main variant should never be used for arrays
8666          of different sizes.  It should only ever be completed with the
8667          size of the array.  */
8668       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8669         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8670     }
8671
8672   /* Lay out the type now that we can get the real answer.  */
8673
8674   layout_type (type);
8675
8676   return value;
8677 }
8678 \f
8679 /* Return zero if something is declared to be a member of type
8680    CTYPE when in the context of CUR_TYPE.  STRING is the error
8681    message to print in that case.  Otherwise, quietly return 1.  */
8682
8683 static int
8684 member_function_or_else (ctype, cur_type, flags)
8685      tree ctype, cur_type;
8686      enum overload_flags flags;
8687 {
8688   if (ctype && ctype != cur_type)
8689     {
8690       if (flags == DTOR_FLAG)
8691         error ("destructor for alien class `%s' cannot be a member",
8692                TYPE_NAME_STRING (ctype));
8693       else
8694         error ("constructor for alien class `%s' cannot be a member",
8695                TYPE_NAME_STRING (ctype));
8696       return 0;
8697     }
8698   return 1;
8699 }
8700 \f
8701 /* Subroutine of `grokdeclarator'.  */
8702
8703 /* Generate errors possibly applicable for a given set of specifiers.
8704    This is for ARM $7.1.2.  */
8705
8706 static void
8707 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8708      tree object;
8709      const char *type;
8710      int virtualp, quals, friendp, raises, inlinep;
8711 {
8712   if (virtualp)
8713     cp_error ("`%D' declared as a `virtual' %s", object, type);
8714   if (inlinep)
8715     cp_error ("`%D' declared as an `inline' %s", object, type);
8716   if (quals)
8717     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8718               object, type);
8719   if (friendp)
8720     cp_error_at ("`%D' declared as a friend", object);
8721   if (raises)
8722     cp_error_at ("`%D' declared with an exception specification", object);
8723 }
8724
8725 /* CTYPE is class type, or null if non-class.
8726    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8727    or METHOD_TYPE.
8728    DECLARATOR is the function's name.
8729    VIRTUALP is truthvalue of whether the function is virtual or not.
8730    FLAGS are to be passed through to `grokclassfn'.
8731    QUALS are qualifiers indicating whether the function is `const'
8732    or `volatile'.
8733    RAISES is a list of exceptions that this function can raise.
8734    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8735    not look, and -1 if we should not call `grokclassfn' at all.
8736
8737    Returns `NULL_TREE' if something goes wrong, after issuing
8738    applicable error messages.  */
8739
8740 static tree
8741 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8742             raises, check, friendp, publicp, inlinep, funcdef_flag,
8743             template_count, in_namespace)
8744      tree ctype, type;
8745      tree declarator;
8746      tree orig_declarator;
8747      int virtualp;
8748      enum overload_flags flags;
8749      tree quals, raises;
8750      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8751      tree in_namespace;
8752 {
8753   tree cname, decl;
8754   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8755   int has_default_arg = 0;
8756   tree t;
8757
8758   if (ctype)
8759     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8760       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8761   else
8762     cname = NULL_TREE;
8763
8764   if (raises)
8765     {
8766       type = build_exception_variant (type, raises);
8767     }
8768
8769   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8770   /* Propagate volatile out from type to decl. */
8771   if (TYPE_VOLATILE (type))
8772     TREE_THIS_VOLATILE (decl) = 1;
8773
8774   /* If this decl has namespace scope, set that up.  */
8775   if (in_namespace)
8776     set_decl_namespace (decl, in_namespace, friendp);
8777   else if (!ctype)
8778     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8779
8780   /* `main' and builtins have implicit 'C' linkage.  */
8781   if ((MAIN_NAME_P (declarator)
8782        || (IDENTIFIER_LENGTH (declarator) > 10
8783            && IDENTIFIER_POINTER (declarator)[0] == '_'
8784            && IDENTIFIER_POINTER (declarator)[1] == '_'
8785            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8786       && current_lang_name == lang_name_cplusplus
8787       && ctype == NULL_TREE
8788       /* NULL_TREE means global namespace.  */
8789       && DECL_CONTEXT (decl) == NULL_TREE)
8790     DECL_LANGUAGE (decl) = lang_c;
8791
8792   /* Should probably propagate const out from type to decl I bet (mrs).  */
8793   if (staticp)
8794     {
8795       DECL_STATIC_FUNCTION_P (decl) = 1;
8796       DECL_CONTEXT (decl) = ctype;
8797     }
8798
8799   if (ctype)
8800     DECL_CONTEXT (decl) = ctype;
8801
8802   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8803     {
8804       if (processing_template_decl)
8805         error ("cannot declare `::main' to be a template");
8806       if (inlinep)
8807         error ("cannot declare `::main' to be inline");
8808       else if (! publicp)
8809         error ("cannot declare `::main' to be static");
8810       inlinep = 0;
8811       publicp = 1;
8812     }
8813
8814   /* Members of anonymous types and local classes have no linkage; make
8815      them internal.  */
8816   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8817                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8818     publicp = 0;
8819
8820   if (publicp)
8821     {
8822       /* [basic.link]: A name with no linkage (notably, the name of a class
8823          or enumeration declared in a local scope) shall not be used to
8824          declare an entity with linkage.
8825
8826          Only check this for public decls for now.  */
8827       t = no_linkage_check (TREE_TYPE (decl));
8828       if (t)
8829         {
8830           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8831             {
8832               if (DECL_EXTERN_C_P (decl))
8833                 /* Allow this; it's pretty common in C.  */;
8834               else
8835                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8836                             decl);
8837             }
8838           else
8839             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8840                         decl, t);
8841         }
8842     }
8843
8844   TREE_PUBLIC (decl) = publicp;
8845   if (! publicp)
8846     {
8847       DECL_INTERFACE_KNOWN (decl) = 1;
8848       DECL_NOT_REALLY_EXTERN (decl) = 1;
8849     }
8850
8851   if (inlinep)
8852     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8853
8854   DECL_EXTERNAL (decl) = 1;
8855   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8856     {
8857       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8858                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8859       quals = NULL_TREE;
8860     }
8861
8862   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8863     grok_op_properties (decl, virtualp, check < 0);
8864
8865   if (ctype && decl_function_context (decl))
8866     DECL_NO_STATIC_CHAIN (decl) = 1;
8867
8868   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8869     if (TREE_PURPOSE (t)
8870         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8871       {
8872         has_default_arg = 1;
8873         break;
8874       }
8875
8876   if (friendp
8877       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8878     {
8879       if (funcdef_flag)
8880         cp_error
8881           ("defining explicit specialization `%D' in friend declaration",
8882            orig_declarator);
8883       else
8884         {
8885           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8886             {
8887               /* Something like `template <class T> friend void f<T>()'.  */
8888               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8889                         orig_declarator);
8890               return NULL_TREE;
8891             }
8892
8893
8894           /* A friend declaration of the form friend void f<>().  Record
8895              the information in the TEMPLATE_ID_EXPR.  */
8896           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8897           DECL_TEMPLATE_INFO (decl)
8898             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8899                          TREE_OPERAND (orig_declarator, 1),
8900                          NULL_TREE);
8901
8902           if (has_default_arg)
8903             {
8904               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8905                         decl);
8906               return NULL_TREE;
8907             }
8908
8909           if (inlinep)
8910             {
8911               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8912                         decl);
8913               return NULL_TREE;
8914             }
8915         }
8916     }
8917
8918   if (has_default_arg)
8919     add_defarg_fn (decl);
8920
8921   /* Plain overloading: will not be grok'd by grokclassfn.  */
8922   if (! ctype && ! processing_template_decl
8923       && !DECL_EXTERN_C_P (decl)
8924       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8925     set_mangled_name_for_decl (decl);
8926
8927   if (funcdef_flag)
8928     /* Make the init_value nonzero so pushdecl knows this is not
8929        tentative.  error_mark_node is replaced later with the BLOCK.  */
8930     DECL_INITIAL (decl) = error_mark_node;
8931
8932   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8933     TREE_NOTHROW (decl) = 1;
8934
8935   /* Caller will do the rest of this.  */
8936   if (check < 0)
8937     return decl;
8938
8939   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8940     DECL_CONSTRUCTOR_P (decl) = 1;
8941
8942   /* Function gets the ugly name, field gets the nice one.  This call
8943      may change the type of the function (because of default
8944      parameters)!  */
8945   if (ctype != NULL_TREE)
8946     grokclassfn (ctype, decl, flags, quals);
8947
8948   decl = check_explicit_specialization (orig_declarator, decl,
8949                                         template_count,
8950                                         2 * (funcdef_flag != 0) +
8951                                         4 * (friendp != 0));
8952   if (decl == error_mark_node)
8953     return NULL_TREE;
8954
8955   if (ctype != NULL_TREE
8956       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8957       && check)
8958     {
8959       tree old_decl;
8960
8961       old_decl = check_classfn (ctype, decl);
8962
8963       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8964         /* Because grokfndecl is always supposed to return a
8965            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8966            here.  We depend on our callers to figure out that its
8967            really a template that's being returned.  */
8968         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8969
8970       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8971           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8972         {
8973           /* Remove the `this' parm added by grokclassfn.
8974              XXX Isn't this done in start_function, too?  */
8975           revert_static_member_fn (decl);
8976           last_function_parms = TREE_CHAIN (last_function_parms);
8977         }
8978       if (old_decl && DECL_ARTIFICIAL (old_decl))
8979         cp_error ("definition of implicitly-declared `%D'", old_decl);
8980
8981       if (old_decl)
8982         {
8983           /* Since we've smashed OLD_DECL to its
8984              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8985           if (TREE_CODE (decl) == TEMPLATE_DECL)
8986             decl = DECL_TEMPLATE_RESULT (decl);
8987
8988           /* Attempt to merge the declarations.  This can fail, in
8989              the case of some illegal specialization declarations.  */
8990           if (!duplicate_decls (decl, old_decl))
8991             cp_error ("no `%#D' member function declared in class `%T'",
8992                       decl, ctype);
8993           return old_decl;
8994         }
8995     }
8996
8997   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8998     return NULL_TREE;
8999
9000   if (ctype == NULL_TREE || check)
9001     return decl;
9002
9003   if (virtualp)
9004     {
9005       DECL_VIRTUAL_P (decl) = 1;
9006       if (DECL_VINDEX (decl) == NULL_TREE)
9007         DECL_VINDEX (decl) = error_mark_node;
9008       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9009     }
9010
9011   return decl;
9012 }
9013
9014 static tree
9015 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9016      tree type;
9017      tree declarator;
9018      RID_BIT_TYPE *specbits_in;
9019      int initialized;
9020      int constp;
9021      tree in_namespace;
9022 {
9023   tree decl;
9024   RID_BIT_TYPE specbits;
9025
9026   specbits = *specbits_in;
9027
9028   if (TREE_CODE (type) == OFFSET_TYPE)
9029     {
9030       /* If you declare a static member so that it
9031          can be initialized, the code will reach here.  */
9032       tree basetype = TYPE_OFFSET_BASETYPE (type);
9033       type = TREE_TYPE (type);
9034       decl = build_lang_decl (VAR_DECL, declarator, type);
9035       DECL_CONTEXT (decl) = basetype;
9036       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9037          templates.  */
9038       if (!uses_template_parms (decl))
9039         {
9040           if (flag_new_abi)
9041             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9042           else
9043             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9044                                                             declarator);
9045         }
9046     }
9047   else
9048     {
9049       tree context;
9050
9051       if (in_namespace)
9052         context = in_namespace;
9053       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9054         context = current_namespace;
9055       else
9056         context = NULL_TREE;
9057
9058       if (processing_template_decl && context)
9059         /* For global variables, declared in a template, we need the
9060            full lang_decl.  */
9061         decl = build_lang_decl (VAR_DECL, declarator, type);
9062       else
9063         decl = build_decl (VAR_DECL, declarator, type);
9064
9065       if (context)
9066         set_decl_namespace (decl, context, 0);
9067
9068       context = DECL_CONTEXT (decl);
9069       if (declarator && context && current_lang_name != lang_name_c)
9070         {
9071           if (flag_new_abi)
9072             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9073           else
9074             DECL_ASSEMBLER_NAME (decl)
9075               = build_static_name (context, declarator);
9076         }
9077     }
9078
9079   if (in_namespace)
9080     set_decl_namespace (decl, in_namespace, 0);
9081
9082   if (RIDBIT_SETP (RID_EXTERN, specbits))
9083     {
9084       DECL_THIS_EXTERN (decl) = 1;
9085       DECL_EXTERNAL (decl) = !initialized;
9086     }
9087
9088   /* In class context, static means one per class,
9089      public access, and static storage.  */
9090   if (DECL_CLASS_SCOPE_P (decl))
9091     {
9092       TREE_PUBLIC (decl) = 1;
9093       TREE_STATIC (decl) = 1;
9094       DECL_EXTERNAL (decl) = 0;
9095     }
9096   /* At top level, either `static' or no s.c. makes a definition
9097      (perhaps tentative), and absence of `static' makes it public.  */
9098   else if (toplevel_bindings_p ())
9099     {
9100       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9101                             && (DECL_THIS_EXTERN (decl) || ! constp));
9102       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9103     }
9104   /* Not at top level, only `static' makes a static definition.  */
9105   else
9106     {
9107       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9108       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9109     }
9110
9111   if (TREE_PUBLIC (decl))
9112     {
9113       /* [basic.link]: A name with no linkage (notably, the name of a class
9114          or enumeration declared in a local scope) shall not be used to
9115          declare an entity with linkage.
9116
9117          Only check this for public decls for now.  */
9118       tree t = no_linkage_check (TREE_TYPE (decl));
9119       if (t)
9120         {
9121           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9122             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9123           else
9124             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9125                         decl, t);
9126         }
9127     }
9128
9129   return decl;
9130 }
9131
9132 /* Create and return a canonical pointer to member function type, for
9133    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9134
9135 tree
9136 build_ptrmemfunc_type (type)
9137      tree type;
9138 {
9139   tree fields[4];
9140   tree t;
9141   tree u;
9142   tree unqualified_variant = NULL_TREE;
9143
9144   /* If a canonical type already exists for this type, use it.  We use
9145      this method instead of type_hash_canon, because it only does a
9146      simple equality check on the list of field members.  */
9147
9148   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9149     return t;
9150
9151   /* Make sure that we always have the unqualified pointer-to-member
9152      type first.  */
9153   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9154     unqualified_variant
9155       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9156
9157   t = make_aggr_type (RECORD_TYPE);
9158   /* Let the front-end know this is a pointer to member function...  */
9159   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9160   /* ... and not really an aggregate.  */
9161   SET_IS_AGGR_TYPE (t, 0);
9162
9163   if (!flag_new_abi)
9164     {
9165       u = make_aggr_type (UNION_TYPE);
9166       SET_IS_AGGR_TYPE (u, 0);
9167       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9168       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9169                               delta_type_node);
9170       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9171       TYPE_NAME (u) = NULL_TREE;
9172
9173       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9174                               delta_type_node);
9175       fields[1] = build_decl (FIELD_DECL, index_identifier,
9176                               delta_type_node);
9177       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9178       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9179     }
9180   else
9181     {
9182       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9183       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9184                               delta_type_node);
9185       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9186     }
9187
9188   /* Zap out the name so that the back-end will give us the debugging
9189      information for this anonymous RECORD_TYPE.  */
9190   TYPE_NAME (t) = NULL_TREE;
9191
9192   /* If this is not the unqualified form of this pointer-to-member
9193      type, set the TYPE_MAIN_VARIANT for this type to be the
9194      unqualified type.  Since they are actually RECORD_TYPEs that are
9195      not variants of each other, we must do this manually.  */
9196   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9197     {
9198       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9199       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9200       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9201       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9202     }
9203
9204   /* Cache this pointer-to-member type so that we can find it again
9205      later.  */
9206   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9207
9208   /* Seems to be wanted.  */
9209   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9210
9211   return t;
9212 }
9213
9214 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9215    Check to see that the definition is valid.  Issue appropriate error
9216    messages.  Return 1 if the definition is particularly bad, or 0
9217    otherwise.  */
9218
9219 int
9220 check_static_variable_definition (decl, type)
9221      tree decl;
9222      tree type;
9223 {
9224   /* Motion 10 at San Diego: If a static const integral data member is
9225      initialized with an integral constant expression, the initializer
9226      may appear either in the declaration (within the class), or in
9227      the definition, but not both.  If it appears in the class, the
9228      member is a member constant.  The file-scope definition is always
9229      required.  */
9230   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9231     {
9232       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9233                 type);
9234       /* If we just return the declaration, crashes will sometimes
9235          occur.  We therefore return void_type_node, as if this was a
9236          friend declaration, to cause callers to completely ignore
9237          this declaration.  */
9238       return 1;
9239     }
9240   else if (!CP_TYPE_CONST_P (type))
9241     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9242               decl);
9243   else if (pedantic && !INTEGRAL_TYPE_P (type))
9244     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9245
9246   return 0;
9247 }
9248
9249 /* Given the SIZE (i.e., number of elements) in an array, compute an
9250    appropriate index type for the array.  If non-NULL, NAME is the
9251    name of the thing being declared.  */
9252
9253 tree
9254 compute_array_index_type (name, size)
9255      tree name;
9256      tree size;
9257 {
9258   tree itype;
9259
9260   /* The size might be the result of a cast. */
9261   STRIP_TYPE_NOPS (size);
9262
9263   /* It might be a const variable or enumeration constant.  */
9264   size = decl_constant_value (size);
9265
9266   /* If this involves a template parameter, it will be a constant at
9267      instantiation time, but we don't know what the value is yet.
9268      Even if no template parameters are involved, we may an expression
9269      that is not a constant; we don't even simplify `1 + 2' when
9270      processing a template.  */
9271   if (processing_template_decl)
9272     {
9273       /* Resolve a qualified reference to an enumerator or static
9274          const data member of ours.  */
9275       if (TREE_CODE (size) == SCOPE_REF
9276           && TREE_OPERAND (size, 0) == current_class_type)
9277         {
9278           tree t = lookup_field (current_class_type,
9279                                  TREE_OPERAND (size, 1), 0, 0);
9280           if (t)
9281             size = t;
9282         }
9283
9284       return build_index_type (build_min (MINUS_EXPR, sizetype,
9285                                           size, integer_one_node));
9286     }
9287
9288   /* The array bound must be an integer type.  */
9289   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9290       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9291       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9292     {
9293       if (name)
9294         cp_error ("size of array `%D' has non-integer type", name);
9295       else
9296         cp_error ("size of array has non-integer type");
9297       size = integer_one_node;
9298     }
9299
9300   /* Normally, the array-bound will be a constant.  */
9301   if (TREE_CODE (size) == INTEGER_CST)
9302     {
9303       /* Check to see if the array bound overflowed.  Make that an
9304          error, no matter how generous we're being.  */
9305       int old_flag_pedantic_errors = flag_pedantic_errors;
9306       int old_pedantic = pedantic;
9307       pedantic = flag_pedantic_errors = 1;
9308       constant_expression_warning (size);
9309       pedantic = old_pedantic;
9310       flag_pedantic_errors = old_flag_pedantic_errors;
9311
9312       /* An array must have a positive number of elements.  */
9313       if (INT_CST_LT (size, integer_zero_node))
9314         {
9315           if (name)
9316             cp_error ("size of array `%D' is negative", name);
9317           else
9318             cp_error ("size of array is negative");
9319           size = integer_one_node;
9320         }
9321       /* Except that an extension we allow zero-sized arrays.  We
9322          always allow them in system headers because glibc uses
9323          them.  */
9324       else if (integer_zerop (size) && pedantic && !in_system_header)
9325         {
9326           if (name)
9327             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9328           else
9329             cp_pedwarn ("ISO C++ forbids zero-size array");
9330         }
9331     }
9332   else if (TREE_CONSTANT (size))
9333     {
9334       /* `(int) &fn' is not a valid array bound.  */
9335       if (name)
9336         cp_error ("size of array `%D' is not an integral constant-expression",
9337                   name);
9338       else
9339         cp_error ("size of array is not an integral constant-expression");
9340     }
9341
9342   /* Compute the index of the largest element in the array.  It is
9343      one less than the number of elements in the array.  */
9344   itype
9345     = fold (cp_build_binary_op (MINUS_EXPR,
9346                                 cp_convert (ssizetype, size),
9347                                 cp_convert (ssizetype,
9348                                             integer_one_node)));
9349
9350   /* Check for variable-sized arrays.  We allow such things as an
9351      extension, even though they are not allowed in ANSI/ISO C++.  */
9352   if (!TREE_CONSTANT (itype))
9353     {
9354       if (pedantic)
9355         {
9356           if (name)
9357             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9358                         name);
9359           else
9360             cp_pedwarn ("ISO C++ forbids variable-size array");
9361         }
9362
9363       /* Create a variable-sized array index type.  */
9364       itype = variable_size (itype);
9365     }
9366   /* Make sure that there was no overflow when creating to a signed
9367      index type.  (For example, on a 32-bit machine, an array with
9368      size 2^32 - 1 is too big.)  */
9369   else if (TREE_OVERFLOW (itype))
9370     {
9371       error ("overflow in array dimension");
9372       TREE_OVERFLOW (itype) = 0;
9373     }
9374
9375   /* Create and return the appropriate index type.  */
9376   return build_index_type (itype);
9377 }
9378
9379 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9380    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9381    with this type.  */
9382
9383 static tree
9384 create_array_type_for_decl (name, type, size)
9385      tree name;
9386      tree type;
9387      tree size;
9388 {
9389   tree itype = NULL_TREE;
9390   const char* error_msg;
9391
9392   /* If things have already gone awry, bail now.  */
9393   if (type == error_mark_node || size == error_mark_node)
9394     return error_mark_node;
9395
9396   /* Assume that everything will go OK.  */
9397   error_msg = NULL;
9398
9399   /* There are some types which cannot be array elements.  */
9400   switch (TREE_CODE (type))
9401     {
9402     case VOID_TYPE:
9403       error_msg = "array of void";
9404       break;
9405
9406     case FUNCTION_TYPE:
9407       error_msg = "array of functions";
9408       break;
9409
9410     case REFERENCE_TYPE:
9411       error_msg = "array of references";
9412       break;
9413
9414     case OFFSET_TYPE:
9415       error_msg = "array of data members";
9416       break;
9417
9418     case METHOD_TYPE:
9419       error_msg = "array of function members";
9420       break;
9421
9422     default:
9423       break;
9424     }
9425
9426   /* If something went wrong, issue an error-message and return.  */
9427   if (error_msg)
9428     {
9429       if (name)
9430         cp_error ("declaration of `%D' as %s", name, error_msg);
9431       else
9432         cp_error ("creating %s", error_msg);
9433
9434       return error_mark_node;
9435     }
9436
9437   /* [dcl.array]
9438
9439      The constant expressions that specify the bounds of the arrays
9440      can be omitted only for the first member of the sequence.  */
9441   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9442     {
9443       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9444                 name);
9445
9446       return error_mark_node;
9447     }
9448
9449   /* Figure out the index type for the array.  */
9450   if (size)
9451     itype = compute_array_index_type (name, size);
9452
9453   return build_cplus_array_type (type, itype);
9454 }
9455
9456 /* Check that it's OK to declare a function with the indicated TYPE.
9457    SFK indicates the kind of special function (if any) that this
9458    function is.  CTYPE is the class of which this function is a
9459    member.  OPTYPE is the type given in a conversion operator
9460    declaration.  Returns the actual return type of the function; that
9461    may be different than TYPE if an error occurs, or for certain
9462    special functions.  */
9463
9464 static tree
9465 check_special_function_return_type (sfk, type, ctype, optype)
9466      special_function_kind sfk;
9467      tree type;
9468      tree ctype;
9469      tree optype;
9470 {
9471   switch (sfk)
9472     {
9473     case sfk_constructor:
9474       if (type)
9475         cp_error ("return type specification for constructor invalid");
9476
9477       /* In the old ABI, we return `this'; in the new ABI we don't
9478          bother.  */
9479       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9480       break;
9481
9482     case sfk_destructor:
9483       if (type)
9484         cp_error ("return type specification for destructor invalid");
9485       type = void_type_node;
9486       break;
9487
9488     case sfk_conversion:
9489       if (type && !same_type_p (type, optype))
9490         cp_error ("operator `%T' declared to return `%T'", optype, type);
9491       else if (type)
9492         cp_pedwarn ("return type specified for `operator %T'",  optype);
9493       type = optype;
9494       break;
9495
9496     default:
9497       my_friendly_abort (20000408);
9498       break;
9499     }
9500
9501   return type;
9502 }
9503
9504 /* Given declspecs and a declarator,
9505    determine the name and type of the object declared
9506    and construct a ..._DECL node for it.
9507    (In one case we can return a ..._TYPE node instead.
9508     For invalid input we sometimes return 0.)
9509
9510    DECLSPECS is a chain of tree_list nodes whose value fields
9511     are the storage classes and type specifiers.
9512
9513    DECL_CONTEXT says which syntactic context this declaration is in:
9514      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9515      FUNCDEF for a function definition.  Like NORMAL but a few different
9516       error messages in each case.  Return value may be zero meaning
9517       this definition is too screwy to try to parse.
9518      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9519       handle member functions (which have FIELD context).
9520       Return value may be zero meaning this definition is too screwy to
9521       try to parse.
9522      PARM for a parameter declaration (either within a function prototype
9523       or before a function body).  Make a PARM_DECL, or return void_type_node.
9524      CATCHPARM for a parameter declaration before a catch clause.
9525      TYPENAME if for a typename (in a cast or sizeof).
9526       Don't make a DECL node; just return the ..._TYPE node.
9527      FIELD for a struct or union field; make a FIELD_DECL.
9528      BITFIELD for a field with specified width.
9529    INITIALIZED is 1 if the decl has an initializer.
9530
9531    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9532    normal attributes in TREE_PURPOSE, or NULL_TREE.
9533
9534    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9535    It may also be so in the PARM case, for a prototype where the
9536    argument type is specified but not the name.
9537
9538    This function is where the complicated C meanings of `static'
9539    and `extern' are interpreted.
9540
9541    For C++, if there is any monkey business to do, the function which
9542    calls this one must do it, i.e., prepending instance variables,
9543    renaming overloaded function names, etc.
9544
9545    Note that for this C++, it is an error to define a method within a class
9546    which does not belong to that class.
9547
9548    Except in the case where SCOPE_REFs are implicitly known (such as
9549    methods within a class being redundantly qualified),
9550    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9551    (class_name::decl_name).  The caller must also deal with this.
9552
9553    If a constructor or destructor is seen, and the context is FIELD,
9554    then the type gains the attribute TREE_HAS_x.  If such a declaration
9555    is erroneous, NULL_TREE is returned.
9556
9557    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9558    function, these are the qualifiers to give to the `this' pointer. We
9559    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9560
9561    May return void_type_node if the declarator turned out to be a friend.
9562    See grokfield for details.  */
9563
9564 tree
9565 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9566      tree declspecs;
9567      tree declarator;
9568      enum decl_context decl_context;
9569      int initialized;
9570      tree attrlist;
9571 {
9572   RID_BIT_TYPE specbits;
9573   int nclasses = 0;
9574   tree spec;
9575   tree type = NULL_TREE;
9576   int longlong = 0;
9577   int constp;
9578   int restrictp;
9579   int volatilep;
9580   int type_quals;
9581   int virtualp, explicitp, friendp, inlinep, staticp;
9582   int explicit_int = 0;
9583   int explicit_char = 0;
9584   int defaulted_int = 0;
9585   tree typedef_decl = NULL_TREE;
9586   const char *name;
9587   tree typedef_type = NULL_TREE;
9588   int funcdef_flag = 0;
9589   enum tree_code innermost_code = ERROR_MARK;
9590   int bitfield = 0;
9591 #if 0
9592   /* See the code below that used this.  */
9593   tree decl_machine_attr = NULL_TREE;
9594 #endif
9595   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9596      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9597   tree init = NULL_TREE;
9598
9599   /* Keep track of what sort of function is being processed
9600      so that we can warn about default return values, or explicit
9601      return values which do not match prescribed defaults.  */
9602   special_function_kind sfk = sfk_none;
9603
9604   tree dname = NULL_TREE;
9605   tree ctype = current_class_type;
9606   tree ctor_return_type = NULL_TREE;
9607   enum overload_flags flags = NO_SPECIAL;
9608   tree quals = NULL_TREE;
9609   tree raises = NULL_TREE;
9610   int template_count = 0;
9611   tree in_namespace = NULL_TREE;
9612   tree inner_attrs;
9613   int ignore_attrs;
9614
9615   RIDBIT_RESET_ALL (specbits);
9616   if (decl_context == FUNCDEF)
9617     funcdef_flag = 1, decl_context = NORMAL;
9618   else if (decl_context == MEMFUNCDEF)
9619     funcdef_flag = -1, decl_context = FIELD;
9620   else if (decl_context == BITFIELD)
9621     bitfield = 1, decl_context = FIELD;
9622
9623   /* Look inside a declarator for the name being declared
9624      and get it as a string, for an error message.  */
9625   {
9626     tree *next = &declarator;
9627     register tree decl;
9628     name = NULL;
9629
9630     while (next && *next)
9631       {
9632         decl = *next;
9633         switch (TREE_CODE (decl))
9634           {
9635           case TREE_LIST:
9636             /* For attributes.  */
9637             next = &TREE_VALUE (decl);
9638             break;
9639
9640           case COND_EXPR:
9641             ctype = NULL_TREE;
9642             next = &TREE_OPERAND (decl, 0);
9643             break;
9644
9645           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9646             {
9647               tree name = TREE_OPERAND (decl, 0);
9648               tree rename = NULL_TREE;
9649
9650               my_friendly_assert (flags == NO_SPECIAL, 152);
9651               flags = DTOR_FLAG;
9652               sfk = sfk_destructor;
9653               if (TREE_CODE (name) == TYPE_DECL)
9654                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9655               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9656               if (ctype == NULL_TREE)
9657                 {
9658                   if (current_class_type == NULL_TREE)
9659                     {
9660                       error ("destructors must be member functions");
9661                       flags = NO_SPECIAL;
9662                     }
9663                   else
9664                     {
9665                       tree t = constructor_name (current_class_name);
9666                       if (t != name)
9667                         rename = t;
9668                     }
9669                 }
9670               else
9671                 {
9672                   tree t = constructor_name (ctype);
9673                   if (t != name)
9674                     rename = t;
9675                 }
9676
9677               if (rename)
9678                 {
9679                   cp_error ("destructor `%T' must match class name `%T'",
9680                             name, rename);
9681                   TREE_OPERAND (decl, 0) = rename;
9682                 }
9683               next = &name;
9684             }
9685             break;
9686
9687           case ADDR_EXPR:       /* C++ reference declaration */
9688             /* Fall through. */
9689           case ARRAY_REF:
9690           case INDIRECT_REF:
9691             ctype = NULL_TREE;
9692             innermost_code = TREE_CODE (decl);
9693             next = &TREE_OPERAND (decl, 0);
9694             break;
9695
9696           case CALL_EXPR:
9697             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9698               {
9699                 /* This is actually a variable declaration using
9700                    constructor syntax.  We need to call start_decl and
9701                    cp_finish_decl so we can get the variable
9702                    initialized...  */
9703
9704                 tree attributes, prefix_attributes;
9705
9706                 *next = TREE_OPERAND (decl, 0);
9707                 init = CALL_DECLARATOR_PARMS (decl);
9708
9709                 if (attrlist)
9710                   {
9711                     attributes = TREE_PURPOSE (attrlist);
9712                     prefix_attributes = TREE_VALUE (attrlist);
9713                   }
9714                 else
9715                   {
9716                     attributes = NULL_TREE;
9717                     prefix_attributes = NULL_TREE;
9718                   }
9719
9720                 decl = start_decl (declarator, declspecs, 1,
9721                                    attributes, prefix_attributes);
9722                 decl_type_access_control (decl);
9723                 if (decl)
9724                   {
9725                     /* Look for __unused__ attribute */
9726                     if (TREE_USED (TREE_TYPE (decl)))
9727                       TREE_USED (decl) = 1;
9728                     finish_decl (decl, init, NULL_TREE);
9729                   }
9730                 else
9731                   cp_error ("invalid declarator");
9732                 return 0;
9733               }
9734             innermost_code = TREE_CODE (decl);
9735             if (decl_context == FIELD && ctype == NULL_TREE)
9736               ctype = current_class_type;
9737             if (ctype
9738                 && TREE_OPERAND (decl, 0)
9739                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9740                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9741                          == constructor_name_full (ctype))
9742                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9743                             == constructor_name (ctype)))))
9744               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9745             next = &TREE_OPERAND (decl, 0);
9746             decl = *next;
9747             if (ctype != NULL_TREE
9748                 && decl != NULL_TREE && flags != DTOR_FLAG
9749                 && decl == constructor_name (ctype))
9750               {
9751                 sfk = sfk_constructor;
9752                 ctor_return_type = ctype;
9753               }
9754             ctype = NULL_TREE;
9755             break;
9756
9757           case TEMPLATE_ID_EXPR:
9758               {
9759                 tree fns = TREE_OPERAND (decl, 0);
9760
9761                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9762                   fns = TREE_OPERAND (fns, 0);
9763
9764                 dname = fns;
9765                 if (TREE_CODE (dname) == COMPONENT_REF)
9766                   dname = TREE_OPERAND (dname, 1);
9767                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9768                   {
9769                     my_friendly_assert (is_overloaded_fn (dname),
9770                                         19990331);
9771                     dname = DECL_NAME (get_first_fn (dname));
9772                   }
9773               }
9774           /* Fall through. */
9775
9776           case IDENTIFIER_NODE:
9777             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9778               dname = decl;
9779
9780             next = 0;
9781
9782             if (is_rid (dname))
9783               {
9784                 cp_error ("declarator-id missing; using reserved word `%D'",
9785                           dname);
9786                 name = IDENTIFIER_POINTER (dname);
9787               }
9788             else if (!IDENTIFIER_TYPENAME_P (dname))
9789               name = IDENTIFIER_POINTER (dname);
9790             else
9791               {
9792                 my_friendly_assert (flags == NO_SPECIAL, 154);
9793                 flags = TYPENAME_FLAG;
9794                 ctor_return_type = TREE_TYPE (dname);
9795                 sfk = sfk_conversion;
9796                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9797                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9798                         == TYPE_DECL))
9799                   name = IDENTIFIER_POINTER (dname);
9800                 else
9801                   name = "<invalid operator>";
9802               }
9803             break;
9804
9805             /* C++ extension */
9806           case SCOPE_REF:
9807             {
9808               /* Perform error checking, and decide on a ctype.  */
9809               tree cname = TREE_OPERAND (decl, 0);
9810               if (cname == NULL_TREE)
9811                 ctype = NULL_TREE;
9812               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9813                 {
9814                   ctype = NULL_TREE;
9815                   in_namespace = TREE_OPERAND (decl, 0);
9816                   TREE_OPERAND (decl, 0) = NULL_TREE;
9817                 }
9818               else if (! is_aggr_type (cname, 1))
9819                 TREE_OPERAND (decl, 0) = NULL_TREE;
9820               /* Must test TREE_OPERAND (decl, 1), in case user gives
9821                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9822               else if (TREE_OPERAND (decl, 1)
9823                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9824                 ctype = cname;
9825               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9826                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9827                 {
9828                   cp_error ("`%T::%D' is not a valid declarator", cname,
9829                             TREE_OPERAND (decl, 1));
9830                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9831                             cname, TREE_OPERAND (decl, 1));
9832                   return void_type_node;
9833                 }
9834               else if (ctype == NULL_TREE)
9835                 ctype = cname;
9836               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9837                 TREE_OPERAND (decl, 0) = ctype;
9838               else
9839                 {
9840                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9841                     {
9842                       cp_error ("type `%T' is not derived from type `%T'",
9843                                 cname, ctype);
9844                       TREE_OPERAND (decl, 0) = NULL_TREE;
9845                     }
9846                   else
9847                     ctype = cname;
9848                 }
9849
9850               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9851                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9852                        == constructor_name_full (ctype))
9853                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9854                           == constructor_name (ctype))))
9855                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9856               next = &TREE_OPERAND (decl, 1);
9857               decl = *next;
9858               if (ctype)
9859                 {
9860                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9861                       && constructor_name (ctype) == decl)
9862                     {
9863                       sfk = sfk_constructor;
9864                       ctor_return_type = ctype;
9865                     }
9866                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9867                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9868                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9869                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9870                     {
9871                       sfk = sfk_destructor;
9872                       ctor_return_type = ctype;
9873                       flags = DTOR_FLAG;
9874                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9875                       next = &TREE_OPERAND (decl, 0);
9876                     }
9877                 }
9878             }
9879             break;
9880
9881           case ERROR_MARK:
9882             next = 0;
9883             break;
9884
9885           case TYPE_DECL:
9886             /* Parse error puts this typespec where
9887                a declarator should go.  */
9888             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9889             if (TREE_TYPE (decl) == current_class_type)
9890               cp_error ("  perhaps you want `%T' for a constructor",
9891                         current_class_name);
9892             dname = DECL_NAME (decl);
9893             name = IDENTIFIER_POINTER (dname);
9894
9895             /* Avoid giving two errors for this.  */
9896             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9897
9898             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9899             *next = dname;
9900             next = 0;
9901             break;
9902
9903           default:
9904             cp_compiler_error ("`%D' as declarator", decl);
9905             return 0; /* We used to do a 155 abort here.  */
9906           }
9907       }
9908   }
9909
9910   /* A function definition's declarator must have the form of
9911      a function declarator.  */
9912
9913   if (funcdef_flag && innermost_code != CALL_EXPR)
9914     return 0;
9915
9916   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9917       && innermost_code != CALL_EXPR
9918       && ! (ctype && declspecs == NULL_TREE))
9919     {
9920       cp_error ("declaration of `%D' as non-function", dname);
9921       return void_type_node;
9922     }
9923
9924   /* Anything declared one level down from the top level
9925      must be one of the parameters of a function
9926      (because the body is at least two levels down).  */
9927
9928   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9929      by not allowing C++ class definitions to specify their parameters
9930      with xdecls (must be spec.d in the parmlist).
9931
9932      Since we now wait to push a class scope until we are sure that
9933      we are in a legitimate method context, we must set oldcname
9934      explicitly (since current_class_name is not yet alive).
9935
9936      We also want to avoid calling this a PARM if it is in a namespace.  */
9937
9938   if (decl_context == NORMAL && !toplevel_bindings_p ())
9939     {
9940       struct binding_level *b = current_binding_level;
9941       current_binding_level = b->level_chain;
9942       if (current_binding_level != 0 && toplevel_bindings_p ())
9943         decl_context = PARM;
9944       current_binding_level = b;
9945     }
9946
9947   if (name == NULL)
9948     name = decl_context == PARM ? "parameter" : "type name";
9949
9950   /* Look through the decl specs and record which ones appear.
9951      Some typespecs are defined as built-in typenames.
9952      Others, the ones that are modifiers of other types,
9953      are represented by bits in SPECBITS: set the bits for
9954      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9955
9956      If there is a typedef name or a type, store the type in TYPE.
9957      This includes builtin typedefs such as `int'.
9958
9959      Set EXPLICIT_INT if the type is `int' or `char' and did not
9960      come from a user typedef.
9961
9962      Set LONGLONG if `long' is mentioned twice.
9963
9964      For C++, constructors and destructors have their own fast treatment.  */
9965
9966   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9967     {
9968       register int i;
9969       register tree id;
9970
9971       /* Certain parse errors slip through.  For example,
9972          `int class;' is not caught by the parser. Try
9973          weakly to recover here.  */
9974       if (TREE_CODE (spec) != TREE_LIST)
9975         return 0;
9976
9977       id = TREE_VALUE (spec);
9978
9979       if (TREE_CODE (id) == IDENTIFIER_NODE)
9980         {
9981           if (id == ridpointers[(int) RID_INT]
9982               || id == ridpointers[(int) RID_CHAR]
9983               || id == ridpointers[(int) RID_BOOL]
9984               || id == ridpointers[(int) RID_WCHAR])
9985             {
9986               if (type)
9987                 {
9988                   if (id == ridpointers[(int) RID_BOOL])
9989                     error ("`bool' is now a keyword");
9990                   else
9991                     cp_error ("extraneous `%T' ignored", id);
9992                 }
9993               else
9994                 {
9995                   if (id == ridpointers[(int) RID_INT])
9996                     explicit_int = 1;
9997                   else if (id == ridpointers[(int) RID_CHAR])
9998                     explicit_char = 1;
9999                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10000                 }
10001               goto found;
10002             }
10003           /* C++ aggregate types.  */
10004           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10005             {
10006               if (type)
10007                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10008               else
10009                 type = IDENTIFIER_TYPE_VALUE (id);
10010               goto found;
10011             }
10012
10013           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10014             {
10015               if (ridpointers[i] == id)
10016                 {
10017                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10018                     {
10019                       if (pedantic && ! in_system_header && warn_long_long)
10020                         pedwarn ("ISO C++ does not support `long long'");
10021                       if (longlong)
10022                         error ("`long long long' is too long for GCC");
10023                       else
10024                         longlong = 1;
10025                     }
10026                   else if (RIDBIT_SETP (i, specbits))
10027                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10028                   RIDBIT_SET (i, specbits);
10029                   goto found;
10030                 }
10031             }
10032         }
10033       /* C++ aggregate types.  */
10034       else if (TREE_CODE (id) == TYPE_DECL)
10035         {
10036           if (type)
10037             cp_error ("multiple declarations `%T' and `%T'", type,
10038                       TREE_TYPE (id));
10039           else
10040             {
10041               type = TREE_TYPE (id);
10042               TREE_VALUE (spec) = type;
10043             }
10044           goto found;
10045         }
10046       if (type)
10047         error ("two or more data types in declaration of `%s'", name);
10048       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10049         {
10050           register tree t = lookup_name (id, 1);
10051           if (!t || TREE_CODE (t) != TYPE_DECL)
10052             error ("`%s' fails to be a typedef or built in type",
10053                    IDENTIFIER_POINTER (id));
10054           else
10055             {
10056               type = TREE_TYPE (t);
10057 #if 0
10058               /* See the code below that used this.  */
10059               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10060 #endif
10061               typedef_decl = t;
10062             }
10063         }
10064       else if (id != error_mark_node)
10065         /* Can't change CLASS nodes into RECORD nodes here!  */
10066         type = id;
10067
10068     found: ;
10069     }
10070
10071   typedef_type = type;
10072
10073   /* No type at all: default to `int', and set DEFAULTED_INT
10074      because it was not a user-defined typedef.  */
10075
10076   if (type == NULL_TREE
10077       && (RIDBIT_SETP (RID_SIGNED, specbits)
10078           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10079           || RIDBIT_SETP (RID_LONG, specbits)
10080           || RIDBIT_SETP (RID_SHORT, specbits)))
10081     {
10082       /* These imply 'int'.  */
10083       type = integer_type_node;
10084       defaulted_int = 1;
10085     }
10086
10087   if (sfk != sfk_none)
10088     type = check_special_function_return_type (sfk, type,
10089                                                ctor_return_type,
10090                                                ctor_return_type);
10091   else if (type == NULL_TREE)
10092     {
10093       int is_main;
10094
10095       explicit_int = -1;
10096
10097           /* We handle `main' specially here, because 'main () { }' is so
10098              common.  With no options, it is allowed.  With -Wreturn-type,
10099              it is a warning.  It is only an error with -pedantic-errors.  */
10100       is_main = (funcdef_flag
10101                  && MAIN_NAME_P (dname)
10102                  && ctype == NULL_TREE
10103                  && in_namespace == NULL_TREE
10104                  && current_namespace == global_namespace);
10105
10106       if (in_system_header || flag_ms_extensions)
10107         /* Allow it, sigh.  */;
10108       else if (pedantic || ! is_main)
10109         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10110                     name);
10111       else if (warn_return_type)
10112         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10113                     name);
10114
10115       type = integer_type_node;
10116     }
10117
10118   ctype = NULL_TREE;
10119
10120   /* Now process the modifiers that were specified
10121      and check for invalid combinations.  */
10122
10123   /* Long double is a special combination.  */
10124
10125   if (RIDBIT_SETP (RID_LONG, specbits)
10126       && TYPE_MAIN_VARIANT (type) == double_type_node)
10127     {
10128       RIDBIT_RESET (RID_LONG, specbits);
10129       type = build_qualified_type (long_double_type_node,
10130                                    CP_TYPE_QUALS (type));
10131     }
10132
10133   /* Check all other uses of type modifiers.  */
10134
10135   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10136       || RIDBIT_SETP (RID_SIGNED, specbits)
10137       || RIDBIT_SETP (RID_LONG, specbits)
10138       || RIDBIT_SETP (RID_SHORT, specbits))
10139     {
10140       int ok = 0;
10141
10142       if (TREE_CODE (type) == REAL_TYPE)
10143         error ("short, signed or unsigned invalid for `%s'", name);
10144       else if (TREE_CODE (type) != INTEGER_TYPE)
10145         error ("long, short, signed or unsigned invalid for `%s'", name);
10146       else if (RIDBIT_SETP (RID_LONG, specbits)
10147                && RIDBIT_SETP (RID_SHORT, specbits))
10148         error ("long and short specified together for `%s'", name);
10149       else if ((RIDBIT_SETP (RID_LONG, specbits)
10150                 || RIDBIT_SETP (RID_SHORT, specbits))
10151                && explicit_char)
10152         error ("long or short specified with char for `%s'", name);
10153       else if ((RIDBIT_SETP (RID_LONG, specbits)
10154                 || RIDBIT_SETP (RID_SHORT, specbits))
10155                && TREE_CODE (type) == REAL_TYPE)
10156         error ("long or short specified with floating type for `%s'", name);
10157       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10158                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10159         error ("signed and unsigned given together for `%s'", name);
10160       else
10161         {
10162           ok = 1;
10163           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10164             {
10165               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10166                        name);
10167               if (flag_pedantic_errors)
10168                 ok = 0;
10169             }
10170         }
10171
10172       /* Discard the type modifiers if they are invalid.  */
10173       if (! ok)
10174         {
10175           RIDBIT_RESET (RID_UNSIGNED, specbits);
10176           RIDBIT_RESET (RID_SIGNED, specbits);
10177           RIDBIT_RESET (RID_LONG, specbits);
10178           RIDBIT_RESET (RID_SHORT, specbits);
10179           longlong = 0;
10180         }
10181     }
10182
10183   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10184       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10185     {
10186       error ("complex invalid for `%s'", name);
10187       RIDBIT_RESET (RID_COMPLEX, specbits);
10188     }
10189
10190   /* Decide whether an integer type is signed or not.
10191      Optionally treat bitfields as signed by default.  */
10192   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10193       /* [class.bit]
10194
10195          It is implementation-defined whether a plain (neither
10196          explicitly signed or unsigned) char, short, int, or long
10197          bit-field is signed or unsigned.
10198
10199          Naturally, we extend this to long long as well.  Note that
10200          this does not include wchar_t.  */
10201       || (bitfield && !flag_signed_bitfields
10202           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10203           /* A typedef for plain `int' without `signed' can be
10204              controlled just like plain `int', but a typedef for
10205              `signed int' cannot be so controlled.  */
10206           && !(typedef_decl
10207                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10208           && (TREE_CODE (type) == INTEGER_TYPE
10209               || TREE_CODE (type) == CHAR_TYPE)
10210           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10211     {
10212       if (longlong)
10213         type = long_long_unsigned_type_node;
10214       else if (RIDBIT_SETP (RID_LONG, specbits))
10215         type = long_unsigned_type_node;
10216       else if (RIDBIT_SETP (RID_SHORT, specbits))
10217         type = short_unsigned_type_node;
10218       else if (type == char_type_node)
10219         type = unsigned_char_type_node;
10220       else if (typedef_decl)
10221         type = unsigned_type (type);
10222       else
10223         type = unsigned_type_node;
10224     }
10225   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10226            && type == char_type_node)
10227     type = signed_char_type_node;
10228   else if (longlong)
10229     type = long_long_integer_type_node;
10230   else if (RIDBIT_SETP (RID_LONG, specbits))
10231     type = long_integer_type_node;
10232   else if (RIDBIT_SETP (RID_SHORT, specbits))
10233     type = short_integer_type_node;
10234
10235   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10236     {
10237       /* If we just have "complex", it is equivalent to
10238          "complex double", but if any modifiers at all are specified it is
10239          the complex form of TYPE.  E.g, "complex short" is
10240          "complex short int".  */
10241
10242       if (defaulted_int && ! longlong
10243           && ! (RIDBIT_SETP (RID_LONG, specbits)
10244                 || RIDBIT_SETP (RID_SHORT, specbits)
10245                 || RIDBIT_SETP (RID_SIGNED, specbits)
10246                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10247         type = complex_double_type_node;
10248       else if (type == integer_type_node)
10249         type = complex_integer_type_node;
10250       else if (type == float_type_node)
10251         type = complex_float_type_node;
10252       else if (type == double_type_node)
10253         type = complex_double_type_node;
10254       else if (type == long_double_type_node)
10255         type = complex_long_double_type_node;
10256       else
10257         type = build_complex_type (type);
10258     }
10259
10260   if (sfk == sfk_conversion
10261       && (RIDBIT_SETP (RID_CONST, specbits)
10262           || RIDBIT_SETP (RID_VOLATILE, specbits)
10263           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10264     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10265               ctor_return_type);
10266
10267   /* Set CONSTP if this declaration is `const', whether by
10268      explicit specification or via a typedef.
10269      Likewise for VOLATILEP.  */
10270
10271   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10272   restrictp =
10273     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10274   volatilep =
10275     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10276   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10277                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10278                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10279   type = cp_build_qualified_type (type, type_quals);
10280   staticp = 0;
10281   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10282   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10283   RIDBIT_RESET (RID_VIRTUAL, specbits);
10284   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10285   RIDBIT_RESET (RID_EXPLICIT, specbits);
10286
10287   if (RIDBIT_SETP (RID_STATIC, specbits))
10288     staticp = 1 + (decl_context == FIELD);
10289
10290   if (virtualp && staticp == 2)
10291     {
10292       cp_error ("member `%D' cannot be declared both virtual and static",
10293                 dname);
10294       staticp = 0;
10295     }
10296   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10297   RIDBIT_RESET (RID_FRIEND, specbits);
10298
10299   /* Warn if two storage classes are given. Default to `auto'.  */
10300
10301   if (RIDBIT_ANY_SET (specbits))
10302     {
10303       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10304       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10305       if (decl_context == PARM && nclasses > 0)
10306         error ("storage class specifiers invalid in parameter declarations");
10307       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10308         {
10309           if (decl_context == PARM)
10310             error ("typedef declaration invalid in parameter declaration");
10311           nclasses++;
10312         }
10313       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10314       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10315     }
10316
10317   /* Give error if `virtual' is used outside of class declaration.  */
10318   if (virtualp
10319       && (current_class_name == NULL_TREE || decl_context != FIELD))
10320     {
10321       error ("virtual outside class declaration");
10322       virtualp = 0;
10323     }
10324
10325   /* Static anonymous unions are dealt with here.  */
10326   if (staticp && decl_context == TYPENAME
10327       && TREE_CODE (declspecs) == TREE_LIST
10328       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10329     decl_context = FIELD;
10330
10331   /* Warn about storage classes that are invalid for certain
10332      kinds of declarations (parameters, typenames, etc.).  */
10333
10334   if (nclasses > 1)
10335     error ("multiple storage classes in declaration of `%s'", name);
10336   else if (decl_context != NORMAL && nclasses > 0)
10337     {
10338       if ((decl_context == PARM || decl_context == CATCHPARM)
10339           && (RIDBIT_SETP (RID_REGISTER, specbits)
10340               || RIDBIT_SETP (RID_AUTO, specbits)))
10341         ;
10342       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10343         ;
10344       else if (decl_context == FIELD
10345                /* C++ allows static class elements  */
10346                && RIDBIT_SETP (RID_STATIC, specbits))
10347         /* C++ also allows inlines and signed and unsigned elements,
10348            but in those cases we don't come in here.  */
10349         ;
10350       else
10351         {
10352           if (decl_context == FIELD)
10353             {
10354               tree tmp = NULL_TREE;
10355               register int op = 0;
10356
10357               if (declarator)
10358                 {
10359                   /* Avoid trying to get an operand off an identifier node.  */
10360                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10361                     tmp = declarator;
10362                   else
10363                     tmp = TREE_OPERAND (declarator, 0);
10364                   op = IDENTIFIER_OPNAME_P (tmp);
10365                   if (IDENTIFIER_TYPENAME_P (tmp))
10366                     {
10367                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10368                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10369                               == TYPE_DECL))
10370                         name = IDENTIFIER_POINTER (tmp);
10371                       else
10372                         name = "<invalid operator>";
10373                     }
10374                 }
10375               error ("storage class specified for %s `%s'",
10376                      op ? "member operator" : "field",
10377                      name);
10378             }
10379           else
10380             {
10381               if (decl_context == PARM || decl_context == CATCHPARM)
10382                 error ("storage class specified for parameter `%s'", name);
10383               else
10384                 error ("storage class specified for typename");
10385             }
10386           RIDBIT_RESET (RID_REGISTER, specbits);
10387           RIDBIT_RESET (RID_AUTO, specbits);
10388           RIDBIT_RESET (RID_EXTERN, specbits);
10389         }
10390     }
10391   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10392     {
10393       if (toplevel_bindings_p ())
10394         {
10395           /* It's common practice (and completely valid) to have a const
10396              be initialized and declared extern.  */
10397           if (!(type_quals & TYPE_QUAL_CONST))
10398             warning ("`%s' initialized and declared `extern'", name);
10399         }
10400       else
10401         error ("`%s' has both `extern' and initializer", name);
10402     }
10403   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10404            && ! toplevel_bindings_p ())
10405     error ("nested function `%s' declared `extern'", name);
10406   else if (toplevel_bindings_p ())
10407     {
10408       if (RIDBIT_SETP (RID_AUTO, specbits))
10409         error ("top-level declaration of `%s' specifies `auto'", name);
10410     }
10411
10412   if (nclasses > 0 && friendp)
10413     error ("storage class specifiers invalid in friend function declarations");
10414
10415   /* Now figure out the structure of the declarator proper.
10416      Descend through it, creating more complex types, until we reach
10417      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10418
10419   inner_attrs = NULL_TREE;
10420   ignore_attrs = 0;
10421
10422   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10423          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10424     {
10425       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10426          an INDIRECT_REF (for *...),
10427          a CALL_EXPR (for ...(...)),
10428          an identifier (for the name being declared)
10429          or a null pointer (for the place in an absolute declarator
10430          where the name was omitted).
10431          For the last two cases, we have just exited the loop.
10432
10433          For C++ it could also be
10434          a SCOPE_REF (for class :: ...).  In this case, we have converted
10435          sensible names to types, and those are the values we use to
10436          qualify the member name.
10437          an ADDR_EXPR (for &...),
10438          a BIT_NOT_EXPR (for destructors)
10439
10440          At this point, TYPE is the type of elements of an array,
10441          or for a function to return, or for a pointer to point to.
10442          After this sequence of ifs, TYPE is the type of the
10443          array or function or pointer, and DECLARATOR has had its
10444          outermost layer removed.  */
10445
10446       if (type == error_mark_node)
10447         {
10448           if (TREE_CODE (declarator) == SCOPE_REF)
10449             declarator = TREE_OPERAND (declarator, 1);
10450           else
10451             declarator = TREE_OPERAND (declarator, 0);
10452           continue;
10453         }
10454       if (quals != NULL_TREE
10455           && (declarator == NULL_TREE
10456               || TREE_CODE (declarator) != SCOPE_REF))
10457         {
10458           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10459             ctype = TYPE_METHOD_BASETYPE (type);
10460           if (ctype != NULL_TREE)
10461             {
10462               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10463               grok_method_quals (ctype, dummy, quals);
10464               type = TREE_TYPE (dummy);
10465               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10466               quals = NULL_TREE;
10467             }
10468         }
10469
10470       /* See the comment for the TREE_LIST case, below.  */
10471       if (ignore_attrs)
10472         ignore_attrs = 0;
10473       else if (inner_attrs)
10474         {
10475           decl_attributes (type, inner_attrs, NULL_TREE);
10476           inner_attrs = NULL_TREE;
10477         }
10478
10479       switch (TREE_CODE (declarator))
10480         {
10481         case TREE_LIST:
10482           {
10483             /* We encode a declarator with embedded attributes using
10484                a TREE_LIST.  The attributes apply to the declarator
10485                directly inside them, so we have to skip an iteration
10486                before applying them to the type.  If the declarator just
10487                inside is the declarator-id, we apply the attrs to the
10488                decl itself.  */
10489             inner_attrs = TREE_PURPOSE (declarator);
10490             ignore_attrs = 1;
10491             declarator = TREE_VALUE (declarator);
10492           }
10493           break;
10494
10495         case ARRAY_REF:
10496           {
10497             register tree size;
10498
10499             size = TREE_OPERAND (declarator, 1);
10500
10501             /* VC++ spells a zero-sized array with [].  */
10502             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10503                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10504               size = integer_zero_node;
10505
10506             declarator = TREE_OPERAND (declarator, 0);
10507
10508             type = create_array_type_for_decl (dname, type, size);
10509
10510             /* VLAs never work as fields. */
10511             if (decl_context == FIELD && !processing_template_decl
10512                 && TREE_CODE (type) == ARRAY_TYPE
10513                 && TYPE_DOMAIN (type) != NULL_TREE
10514                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10515               {
10516                 cp_error ("size of member `%D' is not constant", dname);
10517                 /* Proceed with arbitrary constant size, so that offset
10518                    computations don't get confused. */
10519                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10520                                                    integer_one_node);
10521               }
10522
10523             ctype = NULL_TREE;
10524           }
10525           break;
10526
10527         case CALL_EXPR:
10528           {
10529             tree arg_types;
10530             int funcdecl_p;
10531             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10532             tree inner_decl = TREE_OPERAND (declarator, 0);
10533
10534             /* Declaring a function type.
10535                Make sure we have a valid type for the function to return.  */
10536
10537             /* We now know that the TYPE_QUALS don't apply to the
10538                decl, but to its return type.  */
10539             type_quals = TYPE_UNQUALIFIED;
10540
10541             /* Warn about some types functions can't return.  */
10542
10543             if (TREE_CODE (type) == FUNCTION_TYPE)
10544               {
10545                 error ("`%s' declared as function returning a function", name);
10546                 type = integer_type_node;
10547               }
10548             if (TREE_CODE (type) == ARRAY_TYPE)
10549               {
10550                 error ("`%s' declared as function returning an array", name);
10551                 type = integer_type_node;
10552               }
10553
10554             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10555               inner_decl = TREE_OPERAND (inner_decl, 1);
10556
10557             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10558               inner_decl = dname;
10559
10560             /* Pick up type qualifiers which should be applied to `this'.  */
10561             quals = CALL_DECLARATOR_QUALS (declarator);
10562
10563             /* Pick up the exception specifications.  */
10564             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10565
10566             /* Say it's a definition only for the CALL_EXPR
10567                closest to the identifier.  */
10568             funcdecl_p
10569               = inner_decl
10570               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10571                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10572                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10573
10574             if (ctype == NULL_TREE
10575                 && decl_context == FIELD
10576                 && funcdecl_p
10577                 && (friendp == 0 || dname == current_class_name))
10578               ctype = current_class_type;
10579
10580             if (ctype && sfk == sfk_conversion)
10581               TYPE_HAS_CONVERSION (ctype) = 1;
10582             if (ctype && constructor_name (ctype) == dname)
10583               {
10584                 /* We are within a class's scope. If our declarator name
10585                    is the same as the class name, and we are defining
10586                    a function, then it is a constructor/destructor, and
10587                    therefore returns a void type.  */
10588
10589                 if (flags == DTOR_FLAG)
10590                   {
10591                     /* ISO C++ 12.4/2.  A destructor may not be
10592                        declared const or volatile.  A destructor may
10593                        not be static.  */
10594                     if (staticp == 2)
10595                       error ("destructor cannot be static member function");
10596                     if (quals)
10597                       {
10598                         cp_error ("destructors may not be `%s'",
10599                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10600                         quals = NULL_TREE;
10601                       }
10602                     if (decl_context == FIELD)
10603                       {
10604                         if (! member_function_or_else (ctype,
10605                                                        current_class_type,
10606                                                        flags))
10607                           return void_type_node;
10608                       }
10609                   }
10610                 else            /* It's a constructor.  */
10611                   {
10612                     if (explicitp == 1)
10613                       explicitp = 2;
10614                     /* ISO C++ 12.1.  A constructor may not be
10615                        declared const or volatile.  A constructor may
10616                        not be virtual.  A constructor may not be
10617                        static.  */
10618                     if (staticp == 2)
10619                       error ("constructor cannot be static member function");
10620                     if (virtualp)
10621                       {
10622                         pedwarn ("constructors cannot be declared virtual");
10623                         virtualp = 0;
10624                       }
10625                     if (quals)
10626                       {
10627                         cp_error ("constructors may not be `%s'",
10628                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10629                         quals = NULL_TREE;
10630                       }
10631                     {
10632                       RID_BIT_TYPE tmp_bits;
10633                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10634                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10635                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10636                       if (RIDBIT_ANY_SET (tmp_bits))
10637                         error ("return value type specifier for constructor ignored");
10638                     }
10639                     if (decl_context == FIELD)
10640                       {
10641                         if (! member_function_or_else (ctype,
10642                                                        current_class_type,
10643                                                        flags))
10644                           return void_type_node;
10645                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10646                         if (sfk != sfk_constructor)
10647                           return NULL_TREE;
10648                       }
10649                   }
10650                 if (decl_context == FIELD)
10651                   staticp = 0;
10652               }
10653             else if (friendp)
10654               {
10655                 if (initialized)
10656                   error ("can't initialize friend function `%s'", name);
10657                 if (virtualp)
10658                   {
10659                     /* Cannot be both friend and virtual.  */
10660                     error ("virtual functions cannot be friends");
10661                     RIDBIT_RESET (RID_FRIEND, specbits);
10662                     friendp = 0;
10663                   }
10664                 if (decl_context == NORMAL)
10665                   error ("friend declaration not in class definition");
10666                 if (current_function_decl && funcdef_flag)
10667                   cp_error ("can't define friend function `%s' in a local class definition",
10668                             name);
10669               }
10670
10671             /* Construct the function type and go to the next
10672                inner layer of declarator.  */
10673
10674             declarator = TREE_OPERAND (declarator, 0);
10675
10676             /* FIXME: This is where default args should be fully
10677                processed.  */
10678
10679             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10680
10681             if (declarator && flags == DTOR_FLAG)
10682               {
10683                 /* A destructor declared in the body of a class will
10684                    be represented as a BIT_NOT_EXPR.  But, we just
10685                    want the underlying IDENTIFIER.  */
10686                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10687                   declarator = TREE_OPERAND (declarator, 0);
10688
10689                 if (arg_types != void_list_node)
10690                   {
10691                     cp_error ("destructors may not have parameters");
10692                     arg_types = void_list_node;
10693                     last_function_parms = NULL_TREE;
10694                   }
10695               }
10696
10697             /* ANSI says that `const int foo ();'
10698                does not make the function foo const.  */
10699             type = build_function_type (type, arg_types);
10700
10701             {
10702               tree t;
10703               for (t = arg_types; t; t = TREE_CHAIN (t))
10704                 if (TREE_PURPOSE (t)
10705                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10706                   {
10707                     add_defarg_fn (type);
10708                     break;
10709                   }
10710             }
10711           }
10712           break;
10713
10714         case ADDR_EXPR:
10715         case INDIRECT_REF:
10716           /* Filter out pointers-to-references and references-to-references.
10717              We can get these if a TYPE_DECL is used.  */
10718
10719           if (TREE_CODE (type) == REFERENCE_TYPE)
10720             {
10721               error ("cannot declare %s to references",
10722                      TREE_CODE (declarator) == ADDR_EXPR
10723                      ? "references" : "pointers");
10724               declarator = TREE_OPERAND (declarator, 0);
10725               continue;
10726             }
10727
10728           if (TREE_CODE (type) == OFFSET_TYPE
10729               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10730                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10731             {
10732               cp_error ("cannot declare pointer to `%#T' member",
10733                         TREE_TYPE (type));
10734               type = TREE_TYPE (type);
10735             }
10736
10737           /* Merge any constancy or volatility into the target type
10738              for the pointer.  */
10739
10740           /* We now know that the TYPE_QUALS don't apply to the decl,
10741              but to the target of the pointer.  */
10742           type_quals = TYPE_UNQUALIFIED;
10743
10744           if (TREE_CODE (declarator) == ADDR_EXPR)
10745             {
10746               if (TREE_CODE (type) == VOID_TYPE)
10747                 error ("invalid type: `void &'");
10748               else
10749                 type = build_reference_type (type);
10750             }
10751           else if (TREE_CODE (type) == METHOD_TYPE)
10752             type = build_ptrmemfunc_type (build_pointer_type (type));
10753           else
10754             type = build_pointer_type (type);
10755
10756           /* Process a list of type modifier keywords (such as
10757              const or volatile) that were given inside the `*' or `&'.  */
10758
10759           if (TREE_TYPE (declarator))
10760             {
10761               register tree typemodlist;
10762               int erred = 0;
10763
10764               constp = 0;
10765               volatilep = 0;
10766               restrictp = 0;
10767               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10768                    typemodlist = TREE_CHAIN (typemodlist))
10769                 {
10770                   tree qualifier = TREE_VALUE (typemodlist);
10771
10772                   if (qualifier == ridpointers[(int) RID_CONST])
10773                     constp++;
10774                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10775                     volatilep++;
10776                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10777                     restrictp++;
10778                   else if (!erred)
10779                     {
10780                       erred = 1;
10781                       error ("invalid type modifier within pointer declarator");
10782                     }
10783                 }
10784               if (constp > 1)
10785                 pedwarn ("duplicate `const'");
10786               if (volatilep > 1)
10787                 pedwarn ("duplicate `volatile'");
10788               if (restrictp > 1)
10789                 pedwarn ("duplicate `restrict'");
10790
10791               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10792                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10793                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10794               if (TREE_CODE (declarator) == ADDR_EXPR
10795                   && (constp || volatilep))
10796                 {
10797                   if (constp)
10798                     pedwarn ("discarding `const' applied to a reference");
10799                   if (volatilep)
10800                     pedwarn ("discarding `volatile' applied to a reference");
10801                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10802                 }
10803               type = cp_build_qualified_type (type, type_quals);
10804             }
10805           declarator = TREE_OPERAND (declarator, 0);
10806           ctype = NULL_TREE;
10807           break;
10808
10809         case SCOPE_REF:
10810           {
10811             /* We have converted type names to NULL_TREE if the
10812                name was bogus, or to a _TYPE node, if not.
10813
10814                The variable CTYPE holds the type we will ultimately
10815                resolve to.  The code here just needs to build
10816                up appropriate member types.  */
10817             tree sname = TREE_OPERAND (declarator, 1);
10818             tree t;
10819
10820             /* Destructors can have their visibilities changed as well.  */
10821             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10822               sname = TREE_OPERAND (sname, 0);
10823
10824             if (TREE_COMPLEXITY (declarator) == 0)
10825               /* This needs to be here, in case we are called
10826                  multiple times.  */ ;
10827             else if (TREE_COMPLEXITY (declarator) == -1)
10828               /* Namespace member. */
10829               pop_decl_namespace ();
10830             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10831               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10832             else if (! IS_AGGR_TYPE_CODE
10833                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10834               ;
10835             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10836               {
10837                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10838                    that refer to ctype.  They couldn't be resolved earlier
10839                    because we hadn't pushed into the class yet.
10840                    Example: resolve 'B<T>::type' in
10841                    'B<typename B<T>::type> B<T>::f () { }'.  */
10842                 if (current_template_parms
10843                     && uses_template_parms (type)
10844                     && uses_template_parms (current_class_type))
10845                   {
10846                     tree args = current_template_args ();
10847                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10848                   }
10849
10850                 /* This pop_nested_class corresponds to the
10851                    push_nested_class used to push into class scope for
10852                    parsing the argument list of a function decl, in
10853                    qualified_id.  */
10854                 pop_nested_class ();
10855                 TREE_COMPLEXITY (declarator) = current_class_depth;
10856               }
10857             else
10858               my_friendly_abort (16);
10859
10860             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10861               {
10862                 /* We had a reference to a global decl, or
10863                    perhaps we were given a non-aggregate typedef,
10864                    in which case we cleared this out, and should just
10865                    keep going as though it wasn't there.  */
10866                 declarator = sname;
10867                 continue;
10868               }
10869             ctype = TREE_OPERAND (declarator, 0);
10870
10871             t = ctype;
10872             while (t != NULL_TREE && CLASS_TYPE_P (t))
10873               {
10874                 /* You're supposed to have one `template <...>'
10875                    for every template class, but you don't need one
10876                    for a full specialization.  For example:
10877
10878                      template <class T> struct S{};
10879                      template <> struct S<int> { void f(); };
10880                      void S<int>::f () {}
10881
10882                    is correct; there shouldn't be a `template <>' for
10883                    the definition of `S<int>::f'.  */
10884                 if (CLASSTYPE_TEMPLATE_INFO (t)
10885                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10886                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10887                   template_count += 1;
10888
10889                 t = TYPE_MAIN_DECL (t);
10890                 if (DECL_LANG_SPECIFIC (t))
10891                   t = DECL_CONTEXT (t);
10892                 else
10893                   t = NULL_TREE;
10894               }
10895
10896             if (sname == NULL_TREE)
10897               goto done_scoping;
10898
10899             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10900               {
10901                 /* This is the `standard' use of the scoping operator:
10902                    basetype :: member .  */
10903
10904                 if (ctype == current_class_type)
10905                   {
10906                     /* class A {
10907                          void A::f ();
10908                        };
10909
10910                        Is this ill-formed?  */
10911
10912                     if (pedantic)
10913                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10914                                   ctype, name);
10915                   }
10916                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10917                   {
10918                     if (current_class_type == NULL_TREE
10919                         || friendp)
10920                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10921                                                       TYPE_ARG_TYPES (type));
10922                     else
10923                       {
10924                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10925                                   ctype, name, current_class_type);
10926                         return void_type_node;
10927                       }
10928                   }
10929                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10930                          || COMPLETE_TYPE_P (complete_type (ctype)))
10931                   {
10932                     /* Have to move this code elsewhere in this function.
10933                        this code is used for i.e., typedef int A::M; M *pm;
10934
10935                        It is?  How? jason 10/2/94 */
10936
10937                     if (current_class_type)
10938                       {
10939                         cp_error ("cannot declare member `%T::%s' within `%T'",
10940                                   ctype, name, current_class_type);
10941                         return void_type_node;
10942                       }
10943                     type = build_offset_type (ctype, type);
10944                   }
10945                 else if (uses_template_parms (ctype))
10946                   {
10947                     if (TREE_CODE (type) == FUNCTION_TYPE)
10948                       type
10949                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10950                                                    TYPE_ARG_TYPES (type));
10951                   }
10952                 else
10953                   {
10954                     cp_error ("structure `%T' not yet defined", ctype);
10955                     return error_mark_node;
10956                   }
10957
10958                 declarator = sname;
10959               }
10960             else if (TREE_CODE (sname) == SCOPE_REF)
10961               my_friendly_abort (17);
10962             else
10963               {
10964               done_scoping:
10965                 declarator = TREE_OPERAND (declarator, 1);
10966                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10967                   /* In this case, we will deal with it later.  */
10968                   ;
10969                 else
10970                   {
10971                     if (TREE_CODE (type) == FUNCTION_TYPE)
10972                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10973                                                       TYPE_ARG_TYPES (type));
10974                     else
10975                       type = build_offset_type (ctype, type);
10976                   }
10977               }
10978           }
10979           break;
10980
10981         case BIT_NOT_EXPR:
10982           declarator = TREE_OPERAND (declarator, 0);
10983           break;
10984
10985         case RECORD_TYPE:
10986         case UNION_TYPE:
10987         case ENUMERAL_TYPE:
10988           declarator = NULL_TREE;
10989           break;
10990
10991         case ERROR_MARK:
10992           declarator = NULL_TREE;
10993           break;
10994
10995         default:
10996           my_friendly_abort (158);
10997         }
10998     }
10999
11000   /* See the comment for the TREE_LIST case, above.  */
11001   if (inner_attrs)
11002     {
11003       if (! ignore_attrs)
11004         decl_attributes (type, inner_attrs, NULL_TREE);
11005       else if (attrlist)
11006         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11007       else
11008         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11009     }
11010
11011   /* Now TYPE has the actual type.  */
11012
11013   if (explicitp == 1 || (explicitp && friendp))
11014     {
11015       /* [dcl.fct.spec] The explicit specifier shall only be used in
11016          declarations of constructors within a class definition.  */
11017       error ("only declarations of constructors can be `explicit'");
11018       explicitp = 0;
11019     }
11020
11021   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11022     {
11023       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11024         {
11025           error ("non-member `%s' cannot be declared `mutable'", name);
11026           RIDBIT_RESET (RID_MUTABLE, specbits);
11027         }
11028       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11029         {
11030           error ("non-object member `%s' cannot be declared `mutable'", name);
11031           RIDBIT_RESET (RID_MUTABLE, specbits);
11032         }
11033       else if (TREE_CODE (type) == FUNCTION_TYPE
11034                || TREE_CODE (type) == METHOD_TYPE)
11035         {
11036           error ("function `%s' cannot be declared `mutable'", name);
11037           RIDBIT_RESET (RID_MUTABLE, specbits);
11038         }
11039       else if (staticp)
11040         {
11041           error ("static `%s' cannot be declared `mutable'", name);
11042           RIDBIT_RESET (RID_MUTABLE, specbits);
11043         }
11044       else if (type_quals & TYPE_QUAL_CONST)
11045         {
11046           error ("const `%s' cannot be declared `mutable'", name);
11047           RIDBIT_RESET (RID_MUTABLE, specbits);
11048         }
11049     }
11050
11051   if (declarator == NULL_TREE
11052       || TREE_CODE (declarator) == IDENTIFIER_NODE
11053       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11054           && (TREE_CODE (type) == FUNCTION_TYPE
11055               || TREE_CODE (type) == METHOD_TYPE)))
11056     /* OK */;
11057   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11058     {
11059       cp_error ("template-id `%D' used as a declarator", declarator);
11060       declarator = dname;
11061     }
11062   else
11063     /* Unexpected declarator format.  */
11064     my_friendly_abort (990210);
11065
11066   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11067
11068   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11069     {
11070       tree decl;
11071
11072       /* Note that the grammar rejects storage classes
11073          in typenames, fields or parameters.  */
11074       if (current_lang_name == lang_name_java)
11075         TYPE_FOR_JAVA (type) = 1;
11076
11077       if (decl_context == FIELD)
11078         {
11079           if (declarator == constructor_name (current_class_type))
11080             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11081                         declarator);
11082           decl = build_lang_decl (TYPE_DECL, declarator, type);
11083         }
11084       else
11085         decl = build_decl (TYPE_DECL, declarator, type);
11086
11087       /* If the user declares "typedef struct {...} foo" then the
11088          struct will have an anonymous name.  Fill that name in now.
11089          Nothing can refer to it, so nothing needs know about the name
11090          change.  */
11091       if (type != error_mark_node
11092           && declarator
11093           && TYPE_NAME (type)
11094           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11095           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11096           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11097         {
11098           tree oldname = TYPE_NAME (type);
11099           tree t;
11100
11101           /* Replace the anonymous name with the real name everywhere.  */
11102           lookup_tag_reverse (type, declarator);
11103           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11104             if (TYPE_NAME (t) == oldname)
11105               TYPE_NAME (t) = decl;
11106
11107           if (TYPE_LANG_SPECIFIC (type))
11108             TYPE_WAS_ANONYMOUS (type) = 1;
11109
11110           /* If this is a typedef within a template class, the nested
11111              type is a (non-primary) template.  The name for the
11112              template needs updating as well.  */
11113           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11114             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11115               = TYPE_IDENTIFIER (type);
11116
11117           if (flag_new_abi)
11118             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11119           else
11120             {
11121               /* XXX Temporarily set the scope.
11122                  When returning, start_decl expects it as NULL_TREE,
11123                  and will then then set it using pushdecl. */
11124               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11125               if (current_class_type)
11126                 DECL_CONTEXT (decl) = current_class_type;
11127               else
11128                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11129
11130               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11131               DECL_ASSEMBLER_NAME (decl)
11132                 = get_identifier (build_overload_name (type, 1, 1));
11133               DECL_CONTEXT (decl) = NULL_TREE;
11134             }
11135
11136           /* FIXME remangle member functions; member functions of a
11137              type with external linkage have external linkage.  */
11138         }
11139
11140       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11141         {
11142           cp_error_at ("typedef name may not be class-qualified", decl);
11143           return NULL_TREE;
11144         }
11145       else if (quals)
11146         {
11147           if (ctype == NULL_TREE)
11148             {
11149               if (TREE_CODE (type) != METHOD_TYPE)
11150                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11151               else
11152                 ctype = TYPE_METHOD_BASETYPE (type);
11153             }
11154           if (ctype != NULL_TREE)
11155             grok_method_quals (ctype, decl, quals);
11156         }
11157
11158       if (RIDBIT_SETP (RID_SIGNED, specbits)
11159           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11160         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11161
11162       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11163                       inlinep, friendp, raises != NULL_TREE);
11164
11165       if (initialized)
11166         error ("typedef declaration includes an initializer");
11167
11168       return decl;
11169     }
11170
11171   /* Detect the case of an array type of unspecified size
11172      which came, as such, direct from a typedef name.
11173      We must copy the type, so that each identifier gets
11174      a distinct type, so that each identifier's size can be
11175      controlled separately by its own initializer.  */
11176
11177   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11178       && TYPE_DOMAIN (type) == NULL_TREE)
11179     {
11180       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11181     }
11182
11183   /* If this is a type name (such as, in a cast or sizeof),
11184      compute the type and return it now.  */
11185
11186   if (decl_context == TYPENAME)
11187     {
11188       /* Note that the grammar rejects storage classes
11189          in typenames, fields or parameters.  */
11190       if (type_quals != TYPE_UNQUALIFIED)
11191         type_quals = TYPE_UNQUALIFIED;
11192
11193       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11194       if (friendp)
11195         {
11196           if (type_quals != TYPE_UNQUALIFIED)
11197             {
11198               cp_error ("type qualifiers specified for friend class declaration");
11199               type_quals = TYPE_UNQUALIFIED;
11200             }
11201           if (inlinep)
11202             {
11203               cp_error ("`inline' specified for friend class declaration");
11204               inlinep = 0;
11205             }
11206
11207           /* Only try to do this stuff if we didn't already give up.  */
11208           if (type != integer_type_node)
11209             {
11210               /* A friendly class?  */
11211               if (current_class_type)
11212                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11213               else
11214                 error ("trying to make class `%s' a friend of global scope",
11215                        TYPE_NAME_STRING (type));
11216               type = void_type_node;
11217             }
11218         }
11219       else if (quals)
11220         {
11221           if (ctype == NULL_TREE)
11222             {
11223               if (TREE_CODE (type) != METHOD_TYPE)
11224                 cp_error ("invalid qualifiers on non-member function type");
11225               else
11226                 ctype = TYPE_METHOD_BASETYPE (type);
11227             }
11228           if (ctype)
11229             {
11230               tree dummy = build_decl (TYPE_DECL, declarator, type);
11231               grok_method_quals (ctype, dummy, quals);
11232               type = TREE_TYPE (dummy);
11233             }
11234         }
11235
11236       return type;
11237     }
11238   else if (declarator == NULL_TREE && decl_context != PARM
11239            && decl_context != CATCHPARM
11240            && TREE_CODE (type) != UNION_TYPE
11241            && ! bitfield)
11242     {
11243       cp_error ("abstract declarator `%T' used as declaration", type);
11244       declarator = make_anon_name ();
11245     }
11246
11247   /* `void' at top level (not within pointer)
11248      is allowed only in typedefs or type names.
11249      We don't complain about parms either, but that is because
11250      a better error message can be made later.  */
11251
11252   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11253     {
11254       if (! declarator)
11255         error ("unnamed variable or field declared void");
11256       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11257         {
11258           if (IDENTIFIER_OPNAME_P (declarator))
11259             my_friendly_abort (356);
11260           else
11261             error ("variable or field `%s' declared void", name);
11262         }
11263       else
11264         error ("variable or field declared void");
11265       type = integer_type_node;
11266     }
11267
11268   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11269      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11270
11271   if (decl_context == PARM || decl_context == CATCHPARM)
11272     {
11273       if (ctype || in_namespace)
11274         error ("cannot use `::' in parameter declaration");
11275
11276       /* A parameter declared as an array of T is really a pointer to T.
11277          One declared as a function is really a pointer to a function.
11278          One declared as a member is really a pointer to member.  */
11279
11280       if (TREE_CODE (type) == ARRAY_TYPE)
11281         {
11282           /* Transfer const-ness of array into that of type pointed to.  */
11283           type = build_pointer_type (TREE_TYPE (type));
11284           type_quals = TYPE_UNQUALIFIED;
11285         }
11286       else if (TREE_CODE (type) == FUNCTION_TYPE)
11287         type = build_pointer_type (type);
11288       else if (TREE_CODE (type) == OFFSET_TYPE)
11289         type = build_pointer_type (type);
11290       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11291         {
11292           error ("declaration of `%s' as void", name);
11293           return NULL_TREE;
11294         }
11295     }
11296
11297   {
11298     register tree decl;
11299
11300     if (decl_context == PARM)
11301       {
11302         decl = build_decl (PARM_DECL, declarator, type);
11303
11304         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11305                         inlinep, friendp, raises != NULL_TREE);
11306
11307         /* Compute the type actually passed in the parmlist,
11308            for the case where there is no prototype.
11309            (For example, shorts and chars are passed as ints.)
11310            When there is a prototype, this is overridden later.  */
11311
11312         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11313       }
11314     else if (decl_context == FIELD)
11315       {
11316         if (type == error_mark_node)
11317           {
11318             /* Happens when declaring arrays of sizes which
11319                are error_mark_node, for example.  */
11320             decl = NULL_TREE;
11321           }
11322         else if (in_namespace && !friendp)
11323           {
11324             /* Something like struct S { int N::j; };  */
11325             cp_error ("invalid use of `::'");
11326             decl = NULL_TREE;
11327           }
11328         else if (TREE_CODE (type) == FUNCTION_TYPE)
11329           {
11330             int publicp = 0;
11331             tree function_context;
11332
11333             /* We catch the others as conflicts with the builtin
11334                typedefs.  */
11335             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11336               {
11337                 cp_error ("function `%D' cannot be declared friend",
11338                           declarator);
11339                 friendp = 0;
11340               }
11341
11342             if (friendp == 0)
11343               {
11344                 if (ctype == NULL_TREE)
11345                   ctype = current_class_type;
11346
11347                 if (ctype == NULL_TREE)
11348                   {
11349                     cp_error ("can't make `%D' into a method -- not in a class",
11350                               declarator);
11351                     return void_type_node;
11352                   }
11353
11354                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11355                    ARM 9.5 */
11356                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11357                   {
11358                     cp_error ("function `%D' declared virtual inside a union",
11359                               declarator);
11360                     return void_type_node;
11361                   }
11362
11363                 if (declarator == ansi_opname (NEW_EXPR)
11364                     || declarator == ansi_opname (VEC_NEW_EXPR)
11365                     || declarator == ansi_opname (DELETE_EXPR)
11366                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11367                   {
11368                     if (virtualp)
11369                       {
11370                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11371                                   declarator);
11372                         virtualp = 0;
11373                       }
11374                   }
11375                 else if (staticp < 2)
11376                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11377                                                   TYPE_ARG_TYPES (type));
11378               }
11379
11380             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11381             function_context = (ctype != NULL_TREE) ?
11382               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11383             publicp = (! friendp || ! staticp)
11384               && function_context == NULL_TREE;
11385             decl = grokfndecl (ctype, type,
11386                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11387                                ? declarator : dname,
11388                                declarator,
11389                                virtualp, flags, quals, raises,
11390                                friendp ? -1 : 0, friendp, publicp, inlinep,
11391                                funcdef_flag, template_count, in_namespace);
11392             if (decl == NULL_TREE)
11393               return decl;
11394 #if 0
11395             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11396             /* The decl and setting of decl_machine_attr is also turned off.  */
11397             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11398 #endif
11399
11400             /* [class.conv.ctor]
11401
11402                A constructor declared without the function-specifier
11403                explicit that can be called with a single parameter
11404                specifies a conversion from the type of its first
11405                parameter to the type of its class.  Such a constructor
11406                is called a converting constructor.  */
11407             if (explicitp == 2)
11408               DECL_NONCONVERTING_P (decl) = 1;
11409             else if (DECL_CONSTRUCTOR_P (decl))
11410               {
11411                 /* The constructor can be called with exactly one
11412                    parameter if there is at least one parameter, and
11413                    any subsequent parameters have default arguments.
11414                    We don't look at the first parameter, which is
11415                    really just the `this' parameter for the new
11416                    object.  */
11417                 tree arg_types =
11418                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11419
11420                 /* Skip the `in_chrg' argument too, if present.  */
11421                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11422                   arg_types = TREE_CHAIN (arg_types);
11423
11424                 if (arg_types == void_list_node
11425                     || (arg_types
11426                         && TREE_CHAIN (arg_types)
11427                         && TREE_CHAIN (arg_types) != void_list_node
11428                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11429                   DECL_NONCONVERTING_P (decl) = 1;
11430               }
11431           }
11432         else if (TREE_CODE (type) == METHOD_TYPE)
11433           {
11434             /* We only get here for friend declarations of
11435                members of other classes.  */
11436             /* All method decls are public, so tell grokfndecl to set
11437                TREE_PUBLIC, also.  */
11438             decl = grokfndecl (ctype, type, declarator, declarator,
11439                                virtualp, flags, quals, raises,
11440                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11441                                template_count, in_namespace);
11442             if (decl == NULL_TREE)
11443               return NULL_TREE;
11444           }
11445         else if (!staticp && ! processing_template_decl
11446                  && !COMPLETE_TYPE_P (complete_type (type))
11447                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11448           {
11449             if (declarator)
11450               cp_error ("field `%D' has incomplete type", declarator);
11451             else
11452               cp_error ("name `%T' has incomplete type", type);
11453
11454             /* If we're instantiating a template, tell them which
11455                instantiation made the field's type be incomplete.  */
11456             if (current_class_type
11457                 && TYPE_NAME (current_class_type)
11458                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11459                 && declspecs && TREE_VALUE (declspecs)
11460                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11461               cp_error ("  in instantiation of template `%T'",
11462                         current_class_type);
11463
11464             type = error_mark_node;
11465             decl = NULL_TREE;
11466           }
11467         else
11468           {
11469             if (friendp)
11470               {
11471                 error ("`%s' is neither function nor member function; cannot be declared friend",
11472                        IDENTIFIER_POINTER (declarator));
11473                 friendp = 0;
11474               }
11475             decl = NULL_TREE;
11476           }
11477
11478         if (friendp)
11479           {
11480             /* Friends are treated specially.  */
11481             if (ctype == current_class_type)
11482               warning ("member functions are implicitly friends of their class");
11483             else
11484               {
11485                 tree t = NULL_TREE;
11486                 if (decl && DECL_NAME (decl))
11487                   {
11488                     if (template_class_depth (current_class_type) == 0)
11489                       {
11490                         decl
11491                           = check_explicit_specialization
11492                           (declarator, decl,
11493                            template_count, 2 * (funcdef_flag != 0) + 4);
11494                         if (decl == error_mark_node)
11495                           return error_mark_node;
11496                       }
11497
11498                     t = do_friend (ctype, declarator, decl,
11499                                    last_function_parms, attrlist, flags, quals,
11500                                    funcdef_flag);
11501                   }
11502                 if (t && funcdef_flag)
11503                   return t;
11504
11505                 return void_type_node;
11506               }
11507           }
11508
11509         /* Structure field.  It may not be a function, except for C++ */
11510
11511         if (decl == NULL_TREE)
11512           {
11513             if (initialized)
11514               {
11515                 if (!staticp)
11516                   {
11517                     /* An attempt is being made to initialize a non-static
11518                        member.  But, from [class.mem]:
11519
11520                        4 A member-declarator can contain a
11521                        constant-initializer only if it declares a static
11522                        member (_class.static_) of integral or enumeration
11523                        type, see _class.static.data_.
11524
11525                        This used to be relatively common practice, but
11526                        the rest of the compiler does not correctly
11527                        handle the initialization unless the member is
11528                        static so we make it static below.  */
11529                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11530                                 declarator);
11531                     cp_pedwarn ("making `%D' static", declarator);
11532                     staticp = 1;
11533                   }
11534
11535                 if (uses_template_parms (type))
11536                   /* We'll check at instantiation time.  */
11537                   ;
11538                 else if (check_static_variable_definition (declarator,
11539                                                            type))
11540                   /* If we just return the declaration, crashes
11541                      will sometimes occur.  We therefore return
11542                      void_type_node, as if this was a friend
11543                      declaration, to cause callers to completely
11544                      ignore this declaration.  */
11545                   return void_type_node;
11546               }
11547
11548             /* 9.2p13 [class.mem] */
11549             if (declarator == constructor_name (current_class_type)
11550                 /* The standard does not allow non-static data members
11551                    here either, but we agreed at the 10/99 meeting
11552                    to change that in TC 1 so that they are allowed in
11553                    classes with no user-defined constructors.  */
11554                 && staticp)
11555               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11556                           declarator);
11557
11558             if (staticp)
11559               {
11560                 /* C++ allows static class members.  All other work
11561                    for this is done by grokfield.  */
11562                 decl = build_lang_decl (VAR_DECL, declarator, type);
11563                 TREE_STATIC (decl) = 1;
11564                 /* In class context, 'static' means public access.  */
11565                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11566               }
11567             else
11568               {
11569                 decl = build_decl (FIELD_DECL, declarator, type);
11570                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11571                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11572                   {
11573                     DECL_MUTABLE_P (decl) = 1;
11574                     RIDBIT_RESET (RID_MUTABLE, specbits);
11575                   }
11576               }
11577
11578             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11579                             inlinep, friendp, raises != NULL_TREE);
11580           }
11581       }
11582     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11583       {
11584         tree original_name;
11585         int publicp = 0;
11586
11587         if (! declarator)
11588           return NULL_TREE;
11589
11590         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11591           original_name = dname;
11592         else
11593           original_name = declarator;
11594
11595         if (RIDBIT_SETP (RID_AUTO, specbits))
11596           error ("storage class `auto' invalid for function `%s'", name);
11597         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11598           error ("storage class `register' invalid for function `%s'", name);
11599
11600         /* Function declaration not at top level.
11601            Storage classes other than `extern' are not allowed
11602            and `extern' makes no difference.  */
11603         if (! toplevel_bindings_p ()
11604             && (RIDBIT_SETP (RID_STATIC, specbits)
11605                 || RIDBIT_SETP (RID_INLINE, specbits))
11606             && pedantic)
11607           {
11608             if (RIDBIT_SETP (RID_STATIC, specbits))
11609               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11610             else
11611               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11612           }
11613
11614         if (ctype == NULL_TREE)
11615           {
11616             if (virtualp)
11617               {
11618                 error ("virtual non-class function `%s'", name);
11619                 virtualp = 0;
11620               }
11621           }
11622         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11623           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11624                                           TYPE_ARG_TYPES (type));
11625
11626         /* Record presence of `static'.  */
11627         publicp = (ctype != NULL_TREE
11628                    || RIDBIT_SETP (RID_EXTERN, specbits)
11629                    || !RIDBIT_SETP (RID_STATIC, specbits));
11630
11631         decl = grokfndecl (ctype, type, original_name, declarator,
11632                            virtualp, flags, quals, raises,
11633                            1, friendp,
11634                            publicp, inlinep, funcdef_flag,
11635                            template_count, in_namespace);
11636         if (decl == NULL_TREE)
11637           return NULL_TREE;
11638
11639         if (staticp == 1)
11640           {
11641             int illegal_static = 0;
11642
11643             /* Don't allow a static member function in a class, and forbid
11644                declaring main to be static.  */
11645             if (TREE_CODE (type) == METHOD_TYPE)
11646               {
11647                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11648                 illegal_static = 1;
11649               }
11650             else if (current_function_decl)
11651               {
11652                 /* FIXME need arm citation */
11653                 error ("cannot declare static function inside another function");
11654                 illegal_static = 1;
11655               }
11656
11657             if (illegal_static)
11658               {
11659                 staticp = 0;
11660                 RIDBIT_RESET (RID_STATIC, specbits);
11661               }
11662           }
11663       }
11664     else
11665       {
11666         /* It's a variable.  */
11667
11668         /* An uninitialized decl with `extern' is a reference.  */
11669         decl = grokvardecl (type, declarator, &specbits,
11670                             initialized,
11671                             (type_quals & TYPE_QUAL_CONST) != 0,
11672                             in_namespace);
11673         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11674                         inlinep, friendp, raises != NULL_TREE);
11675
11676         if (ctype)
11677           {
11678             DECL_CONTEXT (decl) = ctype;
11679             if (staticp == 1)
11680               {
11681                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11682                 staticp = 0;
11683                 RIDBIT_RESET (RID_STATIC, specbits);
11684               }
11685             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11686               {
11687                 cp_error ("static member `%D' declared `register'", decl);
11688                 RIDBIT_RESET (RID_REGISTER, specbits);
11689               }
11690             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11691               {
11692                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11693                             decl);
11694                 RIDBIT_RESET (RID_EXTERN, specbits);
11695               }
11696           }
11697       }
11698
11699     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11700
11701     /* Record `register' declaration for warnings on &
11702        and in case doing stupid register allocation.  */
11703
11704     if (RIDBIT_SETP (RID_REGISTER, specbits))
11705       DECL_REGISTER (decl) = 1;
11706
11707     if (RIDBIT_SETP (RID_EXTERN, specbits))
11708       DECL_THIS_EXTERN (decl) = 1;
11709
11710     if (RIDBIT_SETP (RID_STATIC, specbits))
11711       DECL_THIS_STATIC (decl) = 1;
11712
11713     /* Record constancy and volatility.  There's no need to do this
11714        when processing a template; we'll do this for the instantiated
11715        declaration based on the type of DECL.  */
11716     if (!processing_template_decl)
11717       c_apply_type_quals_to_decl (type_quals, decl);
11718
11719     return decl;
11720   }
11721 }
11722 \f
11723 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11724    An empty exprlist is a parmlist.  An exprlist which
11725    contains only identifiers at the global level
11726    is a parmlist.  Otherwise, it is an exprlist.  */
11727
11728 int
11729 parmlist_is_exprlist (exprs)
11730      tree exprs;
11731 {
11732   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11733     return 0;
11734
11735   if (toplevel_bindings_p ())
11736     {
11737       /* At the global level, if these are all identifiers,
11738          then it is a parmlist.  */
11739       while (exprs)
11740         {
11741           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11742             return 1;
11743           exprs = TREE_CHAIN (exprs);
11744         }
11745       return 0;
11746     }
11747   return 1;
11748 }
11749
11750 /* Subroutine of start_function.  Ensure that each of the parameter
11751    types (as listed in PARMS) is complete, as is required for a
11752    function definition.  */
11753
11754 static void
11755 require_complete_types_for_parms (parms)
11756      tree parms;
11757 {
11758   for (; parms; parms = TREE_CHAIN (parms))
11759     {
11760       tree type = TREE_TYPE (parms);
11761
11762       /* Try to complete the TYPE.  */
11763       type = complete_type (type);
11764
11765       if (type == error_mark_node)
11766         continue;
11767
11768       if (!COMPLETE_TYPE_P (type))
11769         {
11770           if (DECL_NAME (parms))
11771             error ("parameter `%s' has incomplete type",
11772                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11773           else
11774             error ("parameter has incomplete type");
11775           TREE_TYPE (parms) = error_mark_node;
11776         }
11777       else
11778         layout_decl (parms, 0);
11779     }
11780 }
11781
11782 /* Returns non-zero if T is a local variable.  */
11783
11784 int
11785 local_variable_p (t)
11786      tree t;
11787 {
11788   if ((TREE_CODE (t) == VAR_DECL
11789        /* A VAR_DECL with a context that is a _TYPE is a static data
11790           member.  */
11791        && !TYPE_P (CP_DECL_CONTEXT (t))
11792        /* Any other non-local variable must be at namespace scope.  */
11793        && !DECL_NAMESPACE_SCOPE_P (t))
11794       || (TREE_CODE (t) == PARM_DECL))
11795     return 1;
11796
11797   return 0;
11798 }
11799
11800 /* Returns non-zero if T is an automatic local variable or a label.
11801    (These are the declarations that need to be remapped when the code
11802    containing them is duplicated.)  */
11803
11804 int
11805 nonstatic_local_decl_p (t)
11806      tree t;
11807 {
11808   return ((local_variable_p (t) && !TREE_STATIC (t))
11809           || TREE_CODE (t) == LABEL_DECL
11810           || TREE_CODE (t) == RESULT_DECL);
11811 }
11812
11813 /* Like local_variable_p, but suitable for use as a tree-walking
11814    function.  */
11815
11816 static tree
11817 local_variable_p_walkfn (tp, walk_subtrees, data)
11818      tree *tp;
11819      int *walk_subtrees ATTRIBUTE_UNUSED;
11820      void *data ATTRIBUTE_UNUSED;
11821 {
11822   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11823           ? *tp : NULL_TREE);
11824 }
11825
11826 /* Check that ARG, which is a default-argument expression for a
11827    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11828    something goes wrong.  DECL may also be a _TYPE node, rather than a
11829    DECL, if there is no DECL available.  */
11830
11831 tree
11832 check_default_argument (decl, arg)
11833      tree decl;
11834      tree arg;
11835 {
11836   tree var;
11837   tree decl_type;
11838
11839   if (TREE_CODE (arg) == DEFAULT_ARG)
11840     /* We get a DEFAULT_ARG when looking at an in-class declaration
11841        with a default argument.  Ignore the argument for now; we'll
11842        deal with it after the class is complete.  */
11843     return arg;
11844
11845   if (processing_template_decl || uses_template_parms (arg))
11846     /* We don't do anything checking until instantiation-time.  Note
11847        that there may be uninstantiated arguments even for an
11848        instantiated function, since default arguments are not
11849        instantiated until they are needed.  */
11850     return arg;
11851
11852   if (TYPE_P (decl))
11853     {
11854       decl_type = decl;
11855       decl = NULL_TREE;
11856     }
11857   else
11858     decl_type = TREE_TYPE (decl);
11859
11860   if (arg == error_mark_node
11861       || decl == error_mark_node
11862       || TREE_TYPE (arg) == error_mark_node
11863       || decl_type == error_mark_node)
11864     /* Something already went wrong.  There's no need to check
11865        further.  */
11866     return error_mark_node;
11867
11868   /* [dcl.fct.default]
11869
11870      A default argument expression is implicitly converted to the
11871      parameter type.  */
11872   if (!TREE_TYPE (arg)
11873       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11874     {
11875       if (decl)
11876         cp_error ("default argument for `%#D' has type `%T'",
11877                   decl, TREE_TYPE (arg));
11878       else
11879         cp_error ("default argument for parameter of type `%T' has type `%T'",
11880                   decl_type, TREE_TYPE (arg));
11881
11882       return error_mark_node;
11883     }
11884
11885   /* [dcl.fct.default]
11886
11887      Local variables shall not be used in default argument
11888      expressions.
11889
11890      The keyword `this' shall not be used in a default argument of a
11891      member function.  */
11892   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11893   if (var)
11894     {
11895       cp_error ("default argument `%E' uses local variable `%D'",
11896                 arg, var);
11897       return error_mark_node;
11898     }
11899
11900   /* All is well.  */
11901   return arg;
11902 }
11903
11904 /* Decode the list of parameter types for a function type.
11905    Given the list of things declared inside the parens,
11906    return a list of types.
11907
11908    The list we receive can have three kinds of elements:
11909    an IDENTIFIER_NODE for names given without types,
11910    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11911    or void_type_node, to mark the end of an argument list
11912    when additional arguments are not permitted (... was not used).
11913
11914    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11915    a mere declaration.  A nonempty identifier-list gets an error message
11916    when FUNCDEF_FLAG is zero.
11917    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11918    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11919
11920    If all elements of the input list contain types,
11921    we return a list of the types.
11922    If all elements contain no type (except perhaps a void_type_node
11923    at the end), we return a null list.
11924    If some have types and some do not, it is an error, and we
11925    return a null list.
11926
11927    Also set last_function_parms to either
11928    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11929    A list of names is converted to a chain of PARM_DECLs
11930    by store_parm_decls so that ultimately it is always a chain of decls.
11931
11932    Note that in C++, parameters can take default values.  These default
11933    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11934    an error to specify default values which are followed by parameters
11935    that have no default values, or an ELLIPSES.  For simplicities sake,
11936    only parameters which are specified with their types can take on
11937    default values.  */
11938
11939 static tree
11940 grokparms (first_parm, funcdef_flag)
11941      tree first_parm;
11942      int funcdef_flag;
11943 {
11944   tree result = NULL_TREE;
11945   tree decls = NULL_TREE;
11946
11947   if (first_parm != NULL_TREE
11948       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11949     {
11950       if (! funcdef_flag)
11951         pedwarn ("parameter names (without types) in function declaration");
11952       last_function_parms = first_parm;
11953       return NULL_TREE;
11954     }
11955   else if (first_parm != NULL_TREE
11956            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11957            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11958     my_friendly_abort (145);
11959   else
11960     {
11961       /* Types were specified.  This is a list of declarators
11962          each represented as a TREE_LIST node.  */
11963       register tree parm, chain;
11964       int any_init = 0, any_error = 0;
11965
11966       if (first_parm != NULL_TREE)
11967         {
11968           tree last_result = NULL_TREE;
11969           tree last_decl = NULL_TREE;
11970
11971           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11972             {
11973               tree type = NULL_TREE, list_node = parm;
11974               register tree decl = TREE_VALUE (parm);
11975               tree init = TREE_PURPOSE (parm);
11976
11977               chain = TREE_CHAIN (parm);
11978               /* @@ weak defense against parse errors.  */
11979               if (TREE_CODE (decl) != VOID_TYPE
11980                   && TREE_CODE (decl) != TREE_LIST)
11981                 {
11982                   /* Give various messages as the need arises.  */
11983                   if (TREE_CODE (decl) == STRING_CST)
11984                     cp_error ("invalid string constant `%E'", decl);
11985                   else if (TREE_CODE (decl) == INTEGER_CST)
11986                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11987                   continue;
11988                 }
11989
11990               if (TREE_CODE (decl) != VOID_TYPE)
11991                 {
11992                   decl = grokdeclarator (TREE_VALUE (decl),
11993                                          TREE_PURPOSE (decl),
11994                                          PARM, init != NULL_TREE,
11995                                          NULL_TREE);
11996                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11997                     continue;
11998
11999                   /* Top-level qualifiers on the parameters are
12000                      ignored for function types.  */
12001                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12002
12003                   if (TREE_CODE (type) == VOID_TYPE)
12004                     decl = void_type_node;
12005                   else if (TREE_CODE (type) == METHOD_TYPE)
12006                     {
12007                       if (DECL_NAME (decl))
12008                         /* Cannot use the decl here because
12009                            we don't have DECL_CONTEXT set up yet.  */
12010                         cp_error ("parameter `%D' invalidly declared method type",
12011                                   DECL_NAME (decl));
12012                       else
12013                         error ("parameter invalidly declared method type");
12014                       type = build_pointer_type (type);
12015                       TREE_TYPE (decl) = type;
12016                     }
12017                   else if (TREE_CODE (type) == OFFSET_TYPE)
12018                     {
12019                       if (DECL_NAME (decl))
12020                         cp_error ("parameter `%D' invalidly declared offset type",
12021                                   DECL_NAME (decl));
12022                       else
12023                         error ("parameter invalidly declared offset type");
12024                       type = build_pointer_type (type);
12025                       TREE_TYPE (decl) = type;
12026                     }
12027                   else if (abstract_virtuals_error (decl, type))
12028                     any_error = 1;  /* Seems like a good idea. */
12029                   else if (POINTER_TYPE_P (type))
12030                     {
12031                       tree t = type;
12032                       while (POINTER_TYPE_P (t)
12033                              || (TREE_CODE (t) == ARRAY_TYPE
12034                                  && TYPE_DOMAIN (t) != NULL_TREE))
12035                         t = TREE_TYPE (t);
12036                       if (TREE_CODE (t) == ARRAY_TYPE)
12037                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12038                                   type,
12039                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12040                     }
12041                 }
12042
12043               if (TREE_CODE (decl) == VOID_TYPE)
12044                 {
12045                   if (result == NULL_TREE)
12046                     {
12047                       result = void_list_node;
12048                       last_result = result;
12049                     }
12050                   else
12051                     {
12052                       TREE_CHAIN (last_result) = void_list_node;
12053                       last_result = void_list_node;
12054                     }
12055                   if (chain
12056                       && (chain != void_list_node || TREE_CHAIN (chain)))
12057                     error ("`void' in parameter list must be entire list");
12058                   break;
12059                 }
12060
12061               /* Since there is a prototype, args are passed in their own types.  */
12062               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12063               if (PROMOTE_PROTOTYPES
12064                   && (TREE_CODE (type) == INTEGER_TYPE
12065                       || TREE_CODE (type) == ENUMERAL_TYPE)
12066                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12067                 DECL_ARG_TYPE (decl) = integer_type_node;
12068               if (!any_error && init)
12069                 {
12070                   any_init++;
12071                   init = check_default_argument (decl, init);
12072                 }
12073               else
12074                 init = NULL_TREE;
12075
12076               if (decls == NULL_TREE)
12077                 {
12078                   decls = decl;
12079                   last_decl = decls;
12080                 }
12081               else
12082                 {
12083                   TREE_CHAIN (last_decl) = decl;
12084                   last_decl = decl;
12085                 }
12086               list_node = tree_cons (init, type, NULL_TREE);
12087               if (result == NULL_TREE)
12088                 {
12089                   result = list_node;
12090                   last_result = result;
12091                 }
12092               else
12093                 {
12094                   TREE_CHAIN (last_result) = list_node;
12095                   last_result = list_node;
12096                 }
12097             }
12098           if (last_result)
12099             TREE_CHAIN (last_result) = NULL_TREE;
12100           /* If there are no parameters, and the function does not end
12101              with `...', then last_decl will be NULL_TREE.  */
12102           if (last_decl != NULL_TREE)
12103             TREE_CHAIN (last_decl) = NULL_TREE;
12104         }
12105     }
12106
12107   last_function_parms = decls;
12108
12109   return result;
12110 }
12111
12112 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12113    FUNCTION_TYPE with the newly parsed version of its default argument, which
12114    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12115
12116 void
12117 replace_defarg (arg, init)
12118      tree arg, init;
12119 {
12120   if (! processing_template_decl
12121       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12122     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12123                 TREE_TYPE (init), TREE_VALUE (arg));
12124   TREE_PURPOSE (arg) = init;
12125 }
12126 \f
12127 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12128    D's arguments allow it to be a copy constructor, or copy assignment
12129    operator.  */
12130
12131 int
12132 copy_args_p (d)
12133      tree d;
12134 {
12135   tree t;
12136
12137   if (!DECL_FUNCTION_MEMBER_P (d))
12138     return 0;
12139
12140   t = FUNCTION_ARG_CHAIN (d);
12141   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12142     t = TREE_CHAIN (t);
12143   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12144       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12145           == DECL_CONTEXT (d))
12146       && (TREE_CHAIN (t) == NULL_TREE
12147           || TREE_CHAIN (t) == void_list_node
12148           || TREE_PURPOSE (TREE_CHAIN (t))))
12149     return 1;
12150   return 0;
12151 }
12152
12153 /* These memoizing functions keep track of special properties which
12154    a class may have.  `grok_ctor_properties' notices whether a class
12155    has a constructor of the form X(X&), and also complains
12156    if the class has a constructor of the form X(X).
12157    `grok_op_properties' takes notice of the various forms of
12158    operator= which are defined, as well as what sorts of type conversion
12159    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12160
12161 int
12162 grok_ctor_properties (ctype, decl)
12163      tree ctype, decl;
12164 {
12165   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12166   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12167
12168   /* When a type has virtual baseclasses, a magical first int argument is
12169      added to any ctor so we can tell if the class has been initialized
12170      yet.  This could screw things up in this function, so we deliberately
12171      ignore the leading int if we're in that situation.  */
12172   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12173     {
12174       my_friendly_assert (parmtypes
12175                           && TREE_VALUE (parmtypes) == integer_type_node,
12176                           980529);
12177       parmtypes = TREE_CHAIN (parmtypes);
12178       parmtype = TREE_VALUE (parmtypes);
12179     }
12180
12181   /* [class.copy]
12182
12183      A non-template constructor for class X is a copy constructor if
12184      its first parameter is of type X&, const X&, volatile X& or const
12185      volatile X&, and either there are no other parameters or else all
12186      other parameters have default arguments.  */
12187   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12188       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12189       && (TREE_CHAIN (parmtypes) == NULL_TREE
12190           || TREE_CHAIN (parmtypes) == void_list_node
12191           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12192       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12193            && is_member_template (DECL_TI_TEMPLATE (decl))))
12194     {
12195       TYPE_HAS_INIT_REF (ctype) = 1;
12196       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12197         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12198     }
12199   /* [class.copy]
12200
12201      A declaration of a constructor for a class X is ill-formed if its
12202      first parameter is of type (optionally cv-qualified) X and either
12203      there are no other parameters or else all other parameters have
12204      default arguments.
12205
12206      We *don't* complain about member template instantiations that
12207      have this form, though; they can occur as we try to decide what
12208      constructor to use during overload resolution.  Since overload
12209      resolution will never prefer such a constructor to the
12210      non-template copy constructor (which is either explicitly or
12211      implicitly defined), there's no need to worry about their
12212      existence.  Theoretically, they should never even be
12213      instantiated, but that's hard to forestall.  */
12214   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12215            && (TREE_CHAIN (parmtypes) == NULL_TREE
12216                || TREE_CHAIN (parmtypes) == void_list_node
12217                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12218            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12219                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12220     {
12221       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12222                 ctype, ctype);
12223       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12224       return 0;
12225     }
12226   else if (TREE_CODE (parmtype) == VOID_TYPE
12227            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12228     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12229
12230   return 1;
12231 }
12232
12233 /* An operator with this code is unary, but can also be binary.  */
12234
12235 static int
12236 ambi_op_p (code)
12237      enum tree_code code;
12238 {
12239   return (code == INDIRECT_REF
12240           || code == ADDR_EXPR
12241           || code == CONVERT_EXPR
12242           || code == NEGATE_EXPR
12243           || code == PREINCREMENT_EXPR
12244           || code == PREDECREMENT_EXPR);
12245 }
12246
12247 /* An operator with this name can only be unary.  */
12248
12249 static int
12250 unary_op_p (code)
12251      enum tree_code code;
12252 {
12253   return (code == TRUTH_NOT_EXPR
12254           || code == BIT_NOT_EXPR
12255           || code == COMPONENT_REF
12256           || code == TYPE_EXPR);
12257 }
12258
12259 /* Do a little sanity-checking on how they declared their operator.  */
12260
12261 void
12262 grok_op_properties (decl, virtualp, friendp)
12263      tree decl;
12264      int virtualp, friendp;
12265 {
12266   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12267   tree argtype;
12268   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12269   tree name = DECL_NAME (decl);
12270   enum tree_code operator_code;
12271   int arity;
12272
12273   /* Count the number of arguments.  */
12274   for (argtype = argtypes, arity = 0;
12275        argtype && argtype != void_list_node;
12276        argtype = TREE_CHAIN (argtype))
12277     ++arity;
12278
12279   if (current_class_type == NULL_TREE)
12280     friendp = 1;
12281
12282   if (DECL_CONV_FN_P (decl))
12283     operator_code = TYPE_EXPR;
12284   else
12285     do
12286       {
12287 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12288         if (ansi_opname (CODE) == name)                                     \
12289           {                                                                 \
12290             operator_code = CODE;                                           \
12291             break;                                                          \
12292           }                                                                 \
12293         else if (ansi_assopname (CODE) == name)                             \
12294           {                                                                 \
12295             operator_code = CODE;                                           \
12296             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12297             break;                                                          \
12298           }
12299
12300 #include "operators.def"
12301 #undef DEF_OPERATOR
12302
12303         my_friendly_abort (20000527);
12304       }
12305     while (0);
12306   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12307   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12308
12309   if (! friendp)
12310     {
12311       switch (operator_code)
12312         {
12313         case CALL_EXPR:
12314           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12315           break;
12316
12317         case ARRAY_REF:
12318           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12319           break;
12320
12321         case COMPONENT_REF:
12322         case MEMBER_REF:
12323           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12324           break;
12325
12326         case NEW_EXPR:
12327           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12328           break;
12329
12330         case DELETE_EXPR:
12331           TYPE_GETS_DELETE (current_class_type) |= 1;
12332           break;
12333
12334         case VEC_NEW_EXPR:
12335           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12336           break;
12337
12338         case VEC_DELETE_EXPR:
12339           TYPE_GETS_DELETE (current_class_type) |= 2;
12340           break;
12341
12342         default:
12343           break;
12344         }
12345     }
12346
12347   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12348     {
12349       /* When the compiler encounters the definition of A::operator new, it
12350          doesn't look at the class declaration to find out if it's static.  */
12351       if (methodp)
12352         revert_static_member_fn (decl);
12353
12354       /* Take care of function decl if we had syntax errors.  */
12355       if (argtypes == NULL_TREE)
12356         TREE_TYPE (decl)
12357           = build_function_type (ptr_type_node,
12358                                  hash_tree_chain (integer_type_node,
12359                                                   void_list_node));
12360       else
12361         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12362     }
12363   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12364     {
12365       if (methodp)
12366         revert_static_member_fn (decl);
12367
12368       if (argtypes == NULL_TREE)
12369         TREE_TYPE (decl)
12370           = build_function_type (void_type_node,
12371                                  hash_tree_chain (ptr_type_node,
12372                                                   void_list_node));
12373       else
12374         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12375     }
12376   else
12377     {
12378       /* An operator function must either be a non-static member function
12379          or have at least one parameter of a class, a reference to a class,
12380          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12381       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12382         {
12383           if (operator_code == TYPE_EXPR
12384               || operator_code == CALL_EXPR
12385               || operator_code == COMPONENT_REF
12386               || operator_code == ARRAY_REF
12387               || operator_code == NOP_EXPR)
12388             cp_error ("`%D' must be a nonstatic member function", decl);
12389           else
12390             {
12391               tree p = argtypes;
12392
12393               if (DECL_STATIC_FUNCTION_P (decl))
12394                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12395
12396               if (p)
12397                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12398                   {
12399                     tree arg = TREE_VALUE (p);
12400                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12401                       arg = TREE_TYPE (arg);
12402
12403                     /* This lets bad template code slip through.  */
12404                     if (IS_AGGR_TYPE (arg)
12405                         || TREE_CODE (arg) == ENUMERAL_TYPE
12406                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12407                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12408                       goto foundaggr;
12409                   }
12410               cp_error
12411                 ("`%D' must have an argument of class or enumerated type",
12412                  decl);
12413             foundaggr:
12414               ;
12415             }
12416         }
12417
12418       if (operator_code == CALL_EXPR)
12419         return;                 /* No restrictions on args. */
12420
12421       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12422         {
12423           tree t = TREE_TYPE (name);
12424           if (! friendp)
12425             {
12426               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12427               const char *what = 0;
12428
12429               if (ref)
12430                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12431
12432               if (TREE_CODE (t) == VOID_TYPE)
12433                 what = "void";
12434               else if (t == current_class_type)
12435                 what = "the same type";
12436               /* Don't force t to be complete here.  */
12437               else if (IS_AGGR_TYPE (t)
12438                        && COMPLETE_TYPE_P (t)
12439                        && DERIVED_FROM_P (t, current_class_type))
12440                 what = "a base class";
12441
12442               if (what)
12443                 warning ("conversion to %s%s will never use a type conversion operator",
12444                          ref ? "a reference to " : "", what);
12445             }
12446         }
12447
12448       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12449           && operator_code == NOP_EXPR)
12450         {
12451           tree parmtype;
12452
12453           if (arity != 2 && methodp)
12454             {
12455               cp_error ("`%D' must take exactly one argument", decl);
12456               return;
12457             }
12458           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12459
12460           /* [class.copy]
12461
12462              A user-declared copy assignment operator X::operator= is
12463              a non-static non-template member function of class X with
12464              exactly one parameter of type X, X&, const X&, volatile
12465              X& or const volatile X&.  */
12466           if (copy_assignment_arg_p (parmtype, virtualp)
12467               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12468                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12469               && ! friendp)
12470             {
12471               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12472               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12473                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12474                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12475             }
12476         }
12477       else if (operator_code == COND_EXPR)
12478         {
12479           /* 13.4.0.3 */
12480           cp_error ("ISO C++ prohibits overloading operator ?:");
12481         }
12482       else if (ambi_op_p (operator_code))
12483         {
12484           if (arity == 1)
12485             /* We pick the one-argument operator codes by default, so
12486                we don't have to change anything.  */
12487             ;
12488           else if (arity == 2)
12489             {
12490               /* If we thought this was a unary operator, we now know
12491                  it to be a binary operator.  */
12492               switch (operator_code)
12493                 {
12494                 case INDIRECT_REF:
12495                   operator_code = MULT_EXPR;
12496                   break;
12497
12498                 case ADDR_EXPR:
12499                   operator_code = BIT_AND_EXPR;
12500                   break;
12501
12502                 case CONVERT_EXPR:
12503                   operator_code = PLUS_EXPR;
12504                   break;
12505
12506                 case NEGATE_EXPR:
12507                   operator_code = MINUS_EXPR;
12508                   break;
12509
12510                 case PREINCREMENT_EXPR:
12511                   operator_code = POSTINCREMENT_EXPR;
12512                   break;
12513
12514                 case PREDECREMENT_EXPR:
12515                   operator_code = POSTDECREMENT_EXPR;
12516                   break;
12517
12518                 default:
12519                   my_friendly_abort (20000527);
12520                 }
12521
12522               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12523
12524               if ((operator_code == POSTINCREMENT_EXPR
12525                    || operator_code == POSTDECREMENT_EXPR)
12526                   && ! processing_template_decl
12527                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12528                 {
12529                   if (methodp)
12530                     cp_error ("postfix `%D' must take `int' as its argument",
12531                               decl);
12532                   else
12533                     cp_error
12534                       ("postfix `%D' must take `int' as its second argument",
12535                        decl);
12536                 }
12537             }
12538           else
12539             {
12540               if (methodp)
12541                 cp_error ("`%D' must take either zero or one argument", decl);
12542               else
12543                 cp_error ("`%D' must take either one or two arguments", decl);
12544             }
12545
12546           /* More Effective C++ rule 6.  */
12547           if (warn_ecpp
12548               && (operator_code == POSTINCREMENT_EXPR
12549                   || operator_code == POSTDECREMENT_EXPR
12550                   || operator_code == PREINCREMENT_EXPR
12551                   || operator_code == PREDECREMENT_EXPR))
12552             {
12553               tree arg = TREE_VALUE (argtypes);
12554               tree ret = TREE_TYPE (TREE_TYPE (decl));
12555               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12556                 arg = TREE_TYPE (arg);
12557               arg = TYPE_MAIN_VARIANT (arg);
12558               if (operator_code == PREINCREMENT_EXPR
12559                   || operator_code == PREDECREMENT_EXPR)
12560                 {
12561                   if (TREE_CODE (ret) != REFERENCE_TYPE
12562                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12563                                        arg))
12564                     cp_warning ("prefix `%D' should return `%T'", decl,
12565                                 build_reference_type (arg));
12566                 }
12567               else
12568                 {
12569                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12570                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12571                 }
12572             }
12573         }
12574       else if (unary_op_p (operator_code))
12575         {
12576           if (arity != 1)
12577             {
12578               if (methodp)
12579                 cp_error ("`%D' must take `void'", decl);
12580               else
12581                 cp_error ("`%D' must take exactly one argument", decl);
12582             }
12583         }
12584       else /* if (binary_op_p (operator_code)) */
12585         {
12586           if (arity != 2)
12587             {
12588               if (methodp)
12589                 cp_error ("`%D' must take exactly one argument", decl);
12590               else
12591                 cp_error ("`%D' must take exactly two arguments", decl);
12592             }
12593
12594           /* More Effective C++ rule 7.  */
12595           if (warn_ecpp
12596               && (operator_code == TRUTH_ANDIF_EXPR
12597                   || operator_code == TRUTH_ORIF_EXPR
12598                   || operator_code == COMPOUND_EXPR))
12599             cp_warning ("user-defined `%D' always evaluates both arguments",
12600                         decl);
12601         }
12602
12603       /* Effective C++ rule 23.  */
12604       if (warn_ecpp
12605           && arity == 2
12606           && (operator_code == PLUS_EXPR
12607               || operator_code == MINUS_EXPR
12608               || operator_code == TRUNC_DIV_EXPR
12609               || operator_code == MULT_EXPR)
12610           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12611         cp_warning ("`%D' should return by value", decl);
12612
12613       /* 13.4.0.8 */
12614       for (; argtypes && argtypes != void_list_node;
12615           argtypes = TREE_CHAIN (argtypes))
12616         if (TREE_PURPOSE (argtypes))
12617           {
12618             TREE_PURPOSE (argtypes) = NULL_TREE;
12619             if (operator_code == POSTINCREMENT_EXPR
12620                 || operator_code == POSTDECREMENT_EXPR)
12621               {
12622                 if (pedantic)
12623                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12624               }
12625             else
12626               cp_error ("`%D' cannot have default arguments", decl);
12627           }
12628
12629     }
12630 }
12631 \f
12632 static const char *
12633 tag_name (code)
12634      enum tag_types code;
12635 {
12636   switch (code)
12637     {
12638     case record_type:
12639       return "struct";
12640     case class_type:
12641       return "class";
12642     case union_type:
12643       return "union ";
12644     case enum_type:
12645       return "enum";
12646     default:
12647       my_friendly_abort (981122);
12648     }
12649 }
12650
12651 /* Get the struct, enum or union (CODE says which) with tag NAME.
12652    Define the tag as a forward-reference if it is not defined.
12653
12654    C++: If a class derivation is given, process it here, and report
12655    an error if multiple derivation declarations are not identical.
12656
12657    If this is a definition, come in through xref_tag and only look in
12658    the current frame for the name (since C++ allows new names in any
12659    scope.)  */
12660
12661 tree
12662 xref_tag (code_type_node, name, globalize)
12663      tree code_type_node;
12664      tree name;
12665      int globalize;
12666 {
12667   enum tag_types tag_code;
12668   enum tree_code code;
12669   register tree ref, t;
12670   struct binding_level *b = current_binding_level;
12671   int got_type = 0;
12672   tree attributes = NULL_TREE;
12673   tree context = NULL_TREE;
12674
12675   /* If we are called from the parser, code_type_node will sometimes be a
12676      TREE_LIST.  This indicates that the user wrote
12677      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12678      use them later.  */
12679   if (TREE_CODE (code_type_node) == TREE_LIST)
12680     {
12681       attributes = TREE_PURPOSE (code_type_node);
12682       code_type_node = TREE_VALUE (code_type_node);
12683     }
12684
12685   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12686   switch (tag_code)
12687     {
12688     case record_type:
12689     case class_type:
12690       code = RECORD_TYPE;
12691       break;
12692     case union_type:
12693       code = UNION_TYPE;
12694       break;
12695     case enum_type:
12696       code = ENUMERAL_TYPE;
12697       break;
12698     default:
12699       my_friendly_abort (18);
12700     }
12701
12702   /* If a cross reference is requested, look up the type
12703      already defined for this tag and return it.  */
12704   if (TYPE_P (name))
12705     {
12706       t = name;
12707       name = TYPE_IDENTIFIER (t);
12708       got_type = 1;
12709     }
12710   else
12711     t = IDENTIFIER_TYPE_VALUE (name);
12712
12713   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12714       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12715     t = NULL_TREE;
12716
12717   if (! globalize)
12718     {
12719       /* If we know we are defining this tag, only look it up in
12720          this scope and don't try to find it as a type.  */
12721       ref = lookup_tag (code, name, b, 1);
12722     }
12723   else
12724     {
12725       if (t)
12726         {
12727           /* [dcl.type.elab] If the identifier resolves to a
12728              typedef-name or a template type-parameter, the
12729              elaborated-type-specifier is ill-formed.  */
12730           if (t != TYPE_MAIN_VARIANT (t)
12731               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12732             cp_pedwarn ("using typedef-name `%D' after `%s'",
12733                         TYPE_NAME (t), tag_name (tag_code));
12734           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12735             cp_error ("using template type parameter `%T' after `%s'",
12736                       t, tag_name (tag_code));
12737
12738           ref = t;
12739         }
12740       else
12741         ref = lookup_tag (code, name, b, 0);
12742
12743       if (! ref)
12744         {
12745           /* Try finding it as a type declaration.  If that wins,
12746              use it.  */
12747           ref = lookup_name (name, 1);
12748
12749           if (ref != NULL_TREE
12750               && processing_template_decl
12751               && DECL_CLASS_TEMPLATE_P (ref)
12752               && template_class_depth (current_class_type) == 0)
12753             /* Since GLOBALIZE is true, we're declaring a global
12754                template, so we want this type.  */
12755             ref = DECL_TEMPLATE_RESULT (ref);
12756
12757           if (ref && TREE_CODE (ref) == TYPE_DECL
12758               && TREE_CODE (TREE_TYPE (ref)) == code)
12759             ref = TREE_TYPE (ref);
12760           else
12761             ref = NULL_TREE;
12762         }
12763
12764       if (ref && current_class_type
12765           && template_class_depth (current_class_type)
12766           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12767         {
12768           /* Since GLOBALIZE is non-zero, we are not looking at a
12769              definition of this tag.  Since, in addition, we are currently
12770              processing a (member) template declaration of a template
12771              class, we must be very careful; consider:
12772
12773                template <class X>
12774                struct S1
12775
12776                template <class U>
12777                struct S2
12778                { template <class V>
12779                friend struct S1; };
12780
12781              Here, the S2::S1 declaration should not be confused with the
12782              outer declaration.  In particular, the inner version should
12783              have a template parameter of level 2, not level 1.  This
12784              would be particularly important if the member declaration
12785              were instead:
12786
12787                template <class V = U> friend struct S1;
12788
12789              say, when we should tsubst into `U' when instantiating
12790              S2.  On the other hand, when presented with:
12791
12792                  template <class T>
12793                  struct S1 {
12794                    template <class U>
12795                    struct S2 {};
12796                    template <class U>
12797                    friend struct S2;
12798                  };
12799
12800               we must find the inner binding eventually.  We
12801               accomplish this by making sure that the new type we
12802               create to represent this declaration has the right
12803               TYPE_CONTEXT.  */
12804           context = TYPE_CONTEXT (ref);
12805           ref = NULL_TREE;
12806         }
12807     }
12808
12809   if (! ref)
12810     {
12811       /* If no such tag is yet defined, create a forward-reference node
12812          and record it as the "definition".
12813          When a real declaration of this type is found,
12814          the forward-reference will be altered into a real type.  */
12815       if (code == ENUMERAL_TYPE)
12816         {
12817           cp_error ("use of enum `%#D' without previous declaration", name);
12818
12819           ref = make_node (ENUMERAL_TYPE);
12820
12821           /* Give the type a default layout like unsigned int
12822              to avoid crashing if it does not get defined.  */
12823           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12824           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12825           TYPE_USER_ALIGN (ref) = 0;
12826           TREE_UNSIGNED (ref) = 1;
12827           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12828           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12829           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12830
12831           /* Enable us to recognize when a type is created in class context.
12832              To do nested classes correctly, this should probably be cleared
12833              out when we leave this classes scope.  Currently this in only
12834              done in `start_enum'.  */
12835
12836           pushtag (name, ref, globalize);
12837         }
12838       else
12839         {
12840           struct binding_level *old_b = class_binding_level;
12841
12842           ref = make_aggr_type (code);
12843           TYPE_CONTEXT (ref) = context;
12844
12845 #ifdef NONNESTED_CLASSES
12846           /* Class types don't nest the way enums do.  */
12847           class_binding_level = (struct binding_level *)0;
12848 #endif
12849           pushtag (name, ref, globalize);
12850           class_binding_level = old_b;
12851         }
12852     }
12853   else
12854     {
12855       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12856         redeclare_class_template (ref, current_template_parms);
12857     }
12858
12859   /* Until the type is defined, tentatively accept whatever
12860      structure tag the user hands us.  */
12861   if (!COMPLETE_TYPE_P (ref)
12862       && ref != current_class_type
12863       /* Have to check this, in case we have contradictory tag info.  */
12864       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12865     {
12866       if (tag_code == class_type)
12867         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12868       else if (tag_code == record_type)
12869         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12870     }
12871
12872   TREE_TYPE (ref) = attributes;
12873
12874   return ref;
12875 }
12876
12877 tree
12878 xref_tag_from_type (old, id, globalize)
12879      tree old, id;
12880      int globalize;
12881 {
12882   tree code_type_node;
12883
12884   if (TREE_CODE (old) == RECORD_TYPE)
12885     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12886                       ? class_type_node : record_type_node);
12887   else
12888     code_type_node = union_type_node;
12889
12890   if (id == NULL_TREE)
12891     id = TYPE_IDENTIFIER (old);
12892
12893   return xref_tag (code_type_node, id, globalize);
12894 }
12895
12896 /* REF is a type (named NAME), for which we have just seen some
12897    baseclasses.  BINFO is a list of those baseclasses; the
12898    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12899    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12900    struct, or union.  */
12901
12902 void
12903 xref_basetypes (code_type_node, name, ref, binfo)
12904      tree code_type_node;
12905      tree name, ref;
12906      tree binfo;
12907 {
12908   /* In the declaration `A : X, Y, ... Z' we mark all the types
12909      (A, X, Y, ..., Z) so we can check for duplicates.  */
12910   tree binfos;
12911   tree base;
12912
12913   int i, len;
12914   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12915
12916   if (tag_code == union_type)
12917     {
12918       cp_error ("derived union `%T' invalid", ref);
12919       return;
12920     }
12921
12922   len = list_length (binfo);
12923
12924   /* First, make sure that any templates in base-classes are
12925      instantiated.  This ensures that if we call ourselves recursively
12926      we do not get confused about which classes are marked and which
12927      are not.  */
12928   for (base = binfo; base; base = TREE_CHAIN (base))
12929     complete_type (TREE_VALUE (base));
12930
12931   SET_CLASSTYPE_MARKED (ref);
12932   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12933
12934   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12935     {
12936       /* The base of a derived struct is public by default.  */
12937       int via_public
12938         = (TREE_PURPOSE (binfo) == access_public_node
12939            || TREE_PURPOSE (binfo) == access_public_virtual_node
12940            || (tag_code != class_type
12941                && (TREE_PURPOSE (binfo) == access_default_node
12942                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12943       int via_protected
12944         = (TREE_PURPOSE (binfo) == access_protected_node
12945            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12946       int via_virtual
12947         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12948            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12949            || TREE_PURPOSE (binfo) == access_public_virtual_node
12950            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12951       tree basetype = TREE_VALUE (binfo);
12952       tree base_binfo;
12953
12954       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12955         basetype = TREE_TYPE (basetype);
12956       if (!basetype
12957           || (TREE_CODE (basetype) != RECORD_TYPE
12958               && TREE_CODE (basetype) != TYPENAME_TYPE
12959               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12960               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12961         {
12962           cp_error ("base type `%T' fails to be a struct or class type",
12963                     TREE_VALUE (binfo));
12964           continue;
12965         }
12966
12967       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12968
12969       /* This code replaces similar code in layout_basetypes.
12970          We put the complete_type first for implicit `typename'.  */
12971       if (!COMPLETE_TYPE_P (basetype)
12972           && ! (current_template_parms && uses_template_parms (basetype)))
12973         {
12974           cp_error ("base class `%T' has incomplete type", basetype);
12975           continue;
12976         }
12977       else
12978         {
12979           if (CLASSTYPE_MARKED (basetype))
12980             {
12981               if (basetype == ref)
12982                 cp_error ("recursive type `%T' undefined", basetype);
12983               else
12984                 cp_error ("duplicate base type `%T' invalid", basetype);
12985               continue;
12986             }
12987
12988           if (TYPE_FOR_JAVA (basetype)
12989               && (current_lang_stack
12990                   == &VARRAY_TREE (current_lang_base, 0)))
12991             TYPE_FOR_JAVA (ref) = 1;
12992
12993           /* Note that the BINFO records which describe individual
12994              inheritances are *not* shared in the lattice!  They
12995              cannot be shared because a given baseclass may be
12996              inherited with different `accessibility' by different
12997              derived classes.  (Each BINFO record describing an
12998              individual inheritance contains flags which say what
12999              the `accessibility' of that particular inheritance is.)  */
13000
13001           base_binfo
13002             = make_binfo (size_zero_node, basetype,
13003                           CLASS_TYPE_P (basetype)
13004                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13005                           CLASS_TYPE_P (basetype)
13006                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13007
13008           TREE_VEC_ELT (binfos, i) = base_binfo;
13009           TREE_VIA_PUBLIC (base_binfo) = via_public;
13010           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13011           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13012           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13013
13014           /* We need to unshare the binfos now so that lookups during class
13015              definition work.  */
13016           unshare_base_binfos (base_binfo);
13017
13018           SET_CLASSTYPE_MARKED (basetype);
13019
13020           /* We are free to modify these bits because they are meaningless
13021              at top level, and BASETYPE is a top-level type.  */
13022           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13023             {
13024               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13025               /* Converting to a virtual base class requires looking
13026                  up the offset of the virtual base.  */
13027               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13028             }
13029
13030           if (CLASS_TYPE_P (basetype))
13031             {
13032               TYPE_HAS_NEW_OPERATOR (ref)
13033                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13034               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13035                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13036               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13037               /* If the base-class uses multiple inheritance, so do we.  */
13038               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13039                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13040               /* Likewise, if converting to a base of the base may require
13041                  code, then we may need to generate code to convert to a
13042                  base as well.  */
13043               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13044                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13045             }
13046
13047           i += 1;
13048         }
13049     }
13050   if (i)
13051     TREE_VEC_LENGTH (binfos) = i;
13052   else
13053     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13054
13055   if (i > 1)
13056     {
13057       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13058       /* If there is more than one non-empty they cannot be at the same
13059          address.  */
13060       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13061     }
13062
13063   /* Unmark all the types.  */
13064   while (--i >= 0)
13065     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13066   CLEAR_CLASSTYPE_MARKED (ref);
13067
13068   /* Now that we know all the base-classes, set up the list of virtual
13069      bases.  */
13070   get_vbase_types (ref);
13071 }
13072
13073 \f
13074 /* Begin compiling the definition of an enumeration type.
13075    NAME is its name (or null if anonymous).
13076    Returns the type object, as yet incomplete.
13077    Also records info about it so that build_enumerator
13078    may be used to declare the individual values as they are read.  */
13079
13080 tree
13081 start_enum (name)
13082      tree name;
13083 {
13084   register tree enumtype = NULL_TREE;
13085   struct binding_level *b = current_binding_level;
13086
13087   /* If this is the real definition for a previous forward reference,
13088      fill in the contents in the same object that used to be the
13089      forward reference.  */
13090
13091   if (name != NULL_TREE)
13092     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13093
13094   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13095     {
13096       cp_error ("multiple definition of `%#T'", enumtype);
13097       cp_error_at ("previous definition here", enumtype);
13098       /* Clear out TYPE_VALUES, and start again.  */
13099       TYPE_VALUES (enumtype) = NULL_TREE;
13100     }
13101   else
13102     {
13103       enumtype = make_node (ENUMERAL_TYPE);
13104       pushtag (name, enumtype, 0);
13105     }
13106
13107   if (current_class_type)
13108     TREE_ADDRESSABLE (b->tags) = 1;
13109
13110   GNU_xref_decl (current_function_decl, enumtype);
13111   return enumtype;
13112 }
13113
13114 /* After processing and defining all the values of an enumeration type,
13115    install their decls in the enumeration type and finish it off.
13116    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13117    Returns ENUMTYPE.  */
13118
13119 tree
13120 finish_enum (enumtype)
13121      tree enumtype;
13122 {
13123   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13124   /* Calculate the maximum value of any enumerator in this type.  */
13125
13126   tree values = TYPE_VALUES (enumtype);
13127   if (values)
13128     {
13129       tree pair;
13130
13131       for (pair = values; pair; pair = TREE_CHAIN (pair))
13132         {
13133           tree decl;
13134           tree value;
13135
13136           /* The TREE_VALUE is a CONST_DECL for this enumeration
13137              constant.  */
13138           decl = TREE_VALUE (pair);
13139
13140           /* [dcl.enum]
13141
13142              Following the closing brace of an enum-specifier, each
13143              enumerator has the type of its enumeration.  Prior to the
13144              closing brace, the type of each enumerator is the type of
13145              its initializing value.  */
13146           TREE_TYPE (decl) = enumtype;
13147
13148           /* The DECL_INITIAL will be NULL if we are processing a
13149              template declaration and this enumeration constant had no
13150              explicit initializer.  */
13151           value = DECL_INITIAL (decl);
13152           if (value && !processing_template_decl)
13153             {
13154               /* Set the TREE_TYPE for the VALUE as well.  That's so
13155                  that when we call decl_constant_value we get an
13156                  entity of the right type (but with the constant
13157                  value).  Since we shouldn't ever call
13158                  decl_constant_value on a template type, there's no
13159                  reason to do that when processing_template_decl.
13160                  And, if the expression is something like a
13161                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13162                  wreak havoc on the intended type of the expression.
13163
13164                  Of course, there's also no point in trying to compute
13165                  minimum or maximum values if we're in a template.  */
13166               TREE_TYPE (value) = enumtype;
13167
13168               if (!minnode)
13169                 minnode = maxnode = value;
13170               else if (tree_int_cst_lt (maxnode, value))
13171                 maxnode = value;
13172               else if (tree_int_cst_lt (value, minnode))
13173                 minnode = value;
13174             }
13175
13176           if (processing_template_decl)
13177             /* If this is just a template, leave the CONST_DECL
13178                alone.  That way tsubst_copy will find CONST_DECLs for
13179                CONST_DECLs, and not INTEGER_CSTs.  */
13180             ;
13181           else
13182             /* In the list we're building up, we want the enumeration
13183                values, not the CONST_DECLs.  */
13184             TREE_VALUE (pair) = value;
13185         }
13186     }
13187   else
13188     maxnode = minnode = integer_zero_node;
13189
13190   TYPE_VALUES (enumtype) = nreverse (values);
13191
13192   if (processing_template_decl)
13193     {
13194       tree scope = current_scope ();
13195       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13196         add_tree (build_min (TAG_DEFN, enumtype));
13197     }
13198   else
13199     {
13200       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13201       int lowprec = min_precision (minnode, unsignedp);
13202       int highprec = min_precision (maxnode, unsignedp);
13203       int precision = MAX (lowprec, highprec);
13204       tree tem;
13205
13206       TYPE_SIZE (enumtype) = NULL_TREE;
13207
13208       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13209
13210       TYPE_PRECISION (enumtype) = precision;
13211       if (unsignedp)
13212         fixup_unsigned_type (enumtype);
13213       else
13214         fixup_signed_type (enumtype);
13215
13216       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13217         /* Use the width of the narrowest normal C type which is wide
13218            enough.  */
13219         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13220                                                     (precision, 1));
13221       else
13222         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13223
13224       TYPE_SIZE (enumtype) = 0;
13225       layout_type (enumtype);
13226
13227       /* Fix up all variant types of this enum type.  */
13228       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13229            tem = TYPE_NEXT_VARIANT (tem))
13230         {
13231           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13232           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13233           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13234           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13235           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13236           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13237           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13238           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13239           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13240           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13241         }
13242
13243       /* Finish debugging output for this type.  */
13244       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13245     }
13246
13247   return enumtype;
13248 }
13249
13250 /* Build and install a CONST_DECL for an enumeration constant of the
13251    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13252    Assignment of sequential values by default is handled here.  */
13253
13254 void
13255 build_enumerator (name, value, enumtype)
13256      tree name;
13257      tree value;
13258      tree enumtype;
13259 {
13260   tree decl;
13261   tree context;
13262   tree type;
13263   tree values;
13264
13265   /* Remove no-op casts from the value.  */
13266   if (value)
13267     STRIP_TYPE_NOPS (value);
13268
13269   if (! processing_template_decl)
13270     {
13271       /* Validate and default VALUE.  */
13272       if (value != NULL_TREE)
13273         {
13274           value = decl_constant_value (value);
13275
13276           if (TREE_CODE (value) == INTEGER_CST)
13277             {
13278               value = default_conversion (value);
13279               constant_expression_warning (value);
13280             }
13281           else
13282             {
13283               cp_error ("enumerator value for `%D' not integer constant", name);
13284               value = NULL_TREE;
13285             }
13286         }
13287
13288       /* Default based on previous value.  */
13289       if (value == NULL_TREE && ! processing_template_decl)
13290         {
13291           tree prev_value;
13292
13293           if (TYPE_VALUES (enumtype))
13294             {
13295               /* The next value is the previous value ... */
13296               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13297               /* ... plus one.  */
13298               value = cp_build_binary_op (PLUS_EXPR,
13299                                           prev_value,
13300                                           integer_one_node);
13301
13302               if (tree_int_cst_lt (value, prev_value))
13303                 cp_error ("overflow in enumeration values at `%D'", name);
13304             }
13305           else
13306             value = integer_zero_node;
13307         }
13308
13309       /* Remove no-op casts from the value.  */
13310       if (value)
13311         STRIP_TYPE_NOPS (value);
13312 #if 0
13313       /* To fix MAX_VAL enum consts. (bkoz)  */
13314       TREE_TYPE (value) = integer_type_node;
13315 #endif
13316     }
13317
13318   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13319      Even in other cases, we will later (in finish_enum) be setting
13320      the type of VALUE.  But, we don't need to make a copy if this
13321      VALUE is one of the enumeration constants for this same
13322      enumeration type.  */
13323   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13324     if (TREE_VALUE (values) == value)
13325       break;
13326   /* If we didn't break out of the loop, then we do need a copy.  */
13327   if (!values && value)
13328     value = copy_node (value);
13329
13330   /* C++ associates enums with global, function, or class declarations.  */
13331   context = current_scope ();
13332
13333   /* Build the actual enumeration constant.  Note that the enumeration
13334     constants have the type of their initializers until the
13335     enumeration is complete:
13336
13337       [ dcl.enum ]
13338
13339       Following the closing brace of an enum-specifier, each enumer-
13340       ator has the type of its enumeration.  Prior to the closing
13341       brace, the type of each enumerator is the type of its
13342       initializing value.
13343
13344     In finish_enum we will reset the type.  Of course, if we're
13345     processing a template, there may be no value.   */
13346   type = value ? TREE_TYPE (value) : NULL_TREE;
13347
13348   if (context && context == current_class_type)
13349     /* This enum declaration is local to the class.  We need the full
13350       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13351     decl = build_lang_decl (CONST_DECL, name, type);
13352   else
13353     /* It's a global enum, or it's local to a function.  (Note local to
13354       a function could mean local to a class method.  */
13355     decl = build_decl (CONST_DECL, name, type);
13356
13357   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13358   DECL_INITIAL (decl) = value;
13359   TREE_READONLY (decl) = 1;
13360
13361   if (context && context == current_class_type)
13362     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13363       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13364       things like `S::i' later.)  */
13365     finish_member_declaration (decl);
13366   else
13367     {
13368       pushdecl (decl);
13369       GNU_xref_decl (current_function_decl, decl);
13370     }
13371
13372   /* Add this enumeration constant to the list for this type.  */
13373   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13374 }
13375
13376 \f
13377 /* We're defining DECL.  Make sure that it's type is OK.  */
13378
13379 static void
13380 check_function_type (decl)
13381      tree decl;
13382 {
13383   tree fntype = TREE_TYPE (decl);
13384   tree return_type = complete_type (TREE_TYPE (fntype));
13385
13386   /* In a function definition, arg types must be complete.  */
13387   require_complete_types_for_parms (current_function_parms);
13388
13389   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13390     {
13391       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13392
13393       /* Make it return void instead, but don't change the
13394          type of the DECL_RESULT, in case we have a named return value.  */
13395       if (TREE_CODE (fntype) == METHOD_TYPE)
13396         {
13397           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13398           TREE_TYPE (decl)
13399             = build_cplus_method_type (ctype,
13400                                        void_type_node,
13401                                        FUNCTION_ARG_CHAIN (decl));
13402         }
13403       else
13404         TREE_TYPE (decl)
13405           = build_function_type (void_type_node,
13406                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13407       TREE_TYPE (decl)
13408         = build_exception_variant (fntype,
13409                                    TYPE_RAISES_EXCEPTIONS (fntype));
13410     }
13411   else
13412     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13413 }
13414
13415 /* Create the FUNCTION_DECL for a function definition.
13416    DECLSPECS and DECLARATOR are the parts of the declaration;
13417    they describe the function's name and the type it returns,
13418    but twisted together in a fashion that parallels the syntax of C.
13419
13420    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13421    DECLARATOR is really the DECL for the function we are about to
13422    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13423    indicating that the function is an inline defined in-class, and
13424    SF_EXPAND indicating that we should generate RTL for this
13425    function.
13426
13427    This function creates a binding context for the function body
13428    as well as setting up the FUNCTION_DECL in current_function_decl.
13429
13430    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13431    (it defines a datum instead), we return 0, which tells
13432    yyparse to report a parse error.
13433
13434    For C++, we must first check whether that datum makes any sense.
13435    For example, "class A local_a(1,2);" means that variable local_a
13436    is an aggregate of type A, which should have a constructor
13437    applied to it with the argument list [1, 2].  */
13438
13439 int
13440 start_function (declspecs, declarator, attrs, flags)
13441      tree declspecs, declarator, attrs;
13442      int flags;
13443 {
13444   tree decl1;
13445   tree ctype = NULL_TREE;
13446   tree fntype;
13447   tree restype;
13448   extern int have_extern_spec;
13449   extern int used_extern_spec;
13450   int doing_friend = 0;
13451   struct binding_level *bl;
13452
13453   /* Sanity check.  */
13454   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13455   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13456
13457   /* This should only be done once on the top most decl.  */
13458   if (have_extern_spec && !used_extern_spec)
13459     {
13460       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13461       used_extern_spec = 1;
13462     }
13463
13464   if (flags & SF_PRE_PARSED)
13465     {
13466       decl1 = declarator;
13467
13468       fntype = TREE_TYPE (decl1);
13469       if (TREE_CODE (fntype) == METHOD_TYPE)
13470         ctype = TYPE_METHOD_BASETYPE (fntype);
13471
13472       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13473          the (lexical) scope of the class in which it is defined.  */
13474       if (!ctype && DECL_FRIEND_P (decl1))
13475         {
13476           ctype = DECL_FRIEND_CONTEXT (decl1);
13477
13478           /* CTYPE could be null here if we're dealing with a template;
13479              for example, `inline friend float foo()' inside a template
13480              will have no CTYPE set.  */
13481           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13482             ctype = NULL_TREE;
13483           else
13484             doing_friend = 1;
13485         }
13486
13487       last_function_parms = DECL_ARGUMENTS (decl1);
13488       last_function_parm_tags = NULL_TREE;
13489     }
13490   else
13491     {
13492       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13493       /* If the declarator is not suitable for a function definition,
13494          cause a syntax error.  */
13495       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13496
13497       fntype = TREE_TYPE (decl1);
13498
13499       restype = TREE_TYPE (fntype);
13500       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13501         {
13502           cp_error ("semicolon missing after declaration of `%#T'", restype);
13503           shadow_tag (build_tree_list (NULL_TREE, restype));
13504           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13505           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13506             fntype = build_function_type (integer_type_node,
13507                                           TYPE_ARG_TYPES (fntype));
13508           else
13509             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13510                                               integer_type_node,
13511                                               TYPE_ARG_TYPES (fntype));
13512           TREE_TYPE (decl1) = fntype;
13513         }
13514
13515       if (TREE_CODE (fntype) == METHOD_TYPE)
13516         ctype = TYPE_METHOD_BASETYPE (fntype);
13517       else if (DECL_MAIN_P (decl1))
13518         {
13519           /* If this doesn't return integer_type, complain.  */
13520           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13521             {
13522               if (pedantic || warn_return_type)
13523                 pedwarn ("return type for `main' changed to `int'");
13524               TREE_TYPE (decl1) = fntype = default_function_type;
13525             }
13526         }
13527     }
13528
13529   /* Sometimes we don't notice that a function is a static member, and
13530      build a METHOD_TYPE for it.  Fix that up now.  */
13531   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13532       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13533     {
13534       revert_static_member_fn (decl1);
13535       last_function_parms = TREE_CHAIN (last_function_parms);
13536       ctype = NULL_TREE;
13537     }
13538
13539   /* Warn if function was previously implicitly declared
13540      (but not if we warned then).  */
13541   if (! warn_implicit
13542       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13543     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13544
13545   /* Set up current_class_type, and enter the scope of the class, if
13546      appropriate.  */
13547   if (ctype)
13548     push_nested_class (ctype, 1);
13549   else if (DECL_STATIC_FUNCTION_P (decl1))
13550     push_nested_class (DECL_CONTEXT (decl1), 2);
13551
13552   /* Now that we have entered the scope of the class, we must restore
13553      the bindings for any template parameters surrounding DECL1, if it
13554      is an inline member template.  (Order is important; consider the
13555      case where a template parameter has the same name as a field of
13556      the class.)  It is not until after this point that
13557      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13558   if (flags & SF_INCLASS_INLINE)
13559     maybe_begin_member_template_processing (decl1);
13560
13561   /* Effective C++ rule 15.  See also c_expand_return.  */
13562   if (warn_ecpp
13563       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13564       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13565     cp_warning ("`operator=' should return a reference to `*this'");
13566
13567   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13568      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13569   if (!DECL_INITIAL (decl1))
13570     DECL_INITIAL (decl1) = error_mark_node;
13571
13572 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13573   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13574 #endif
13575
13576   /* This function exists in static storage.
13577      (This does not mean `static' in the C sense!)  */
13578   TREE_STATIC (decl1) = 1;
13579
13580   /* We must call push_template_decl after current_class_type is set
13581      up.  (If we are processing inline definitions after exiting a
13582      class scope, current_class_type will be NULL_TREE until set above
13583      by push_nested_class.)  */
13584   if (processing_template_decl)
13585     decl1 = push_template_decl (decl1);
13586
13587   /* We are now in the scope of the function being defined.  */
13588   current_function_decl = decl1;
13589
13590   /* Save the parm names or decls from this function's declarator
13591      where store_parm_decls will find them.  */
13592   current_function_parms = last_function_parms;
13593   current_function_parm_tags = last_function_parm_tags;
13594
13595   /* Make sure the parameter and return types are reasonable.  When
13596      you declare a function, these types can be incomplete, but they
13597      must be complete when you define the function.  */
13598   if (! processing_template_decl)
13599     check_function_type (decl1);
13600
13601   /* Build the return declaration for the function.  */
13602   restype = TREE_TYPE (fntype);
13603   if (!processing_template_decl)
13604     {
13605       if (!DECL_RESULT (decl1))
13606         {
13607           DECL_RESULT (decl1)
13608             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13609           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13610                                       DECL_RESULT (decl1));
13611         }
13612     }
13613   else
13614     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13615     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13616
13617   /* Initialize RTL machinery.  We cannot do this until
13618      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13619      even when processing a template; this is how we get
13620      CFUN set up, and our per-function variables initialized.  */
13621   bl = current_binding_level;
13622   init_function_start (decl1, input_filename, lineno);
13623   current_binding_level = bl;
13624   expanding_p = (flags & SF_EXPAND) != 0;
13625
13626   /* Even though we're inside a function body, we still don't want to
13627      call expand_expr to calculate the size of a variable-sized array.
13628      We haven't necessarily assigned RTL to all variables yet, so it's
13629      not safe to try to expand expressions involving them.  */
13630   immediate_size_expand = 0;
13631   cfun->x_dont_save_pending_sizes_p = 1;
13632
13633   /* If we're building a statement-tree, start the tree now.  */
13634   if (processing_template_decl || !expanding_p)
13635     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13636
13637   /* Let the user know we're compiling this function.  */
13638   announce_function (decl1);
13639
13640   /* Record the decl so that the function name is defined.
13641      If we already have a decl for this name, and it is a FUNCTION_DECL,
13642      use the old decl.  */
13643   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13644     {
13645       /* A specialization is not used to guide overload resolution.  */
13646       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13647           && ! DECL_FUNCTION_MEMBER_P (decl1))
13648         decl1 = pushdecl (decl1);
13649       else
13650         {
13651           /* We need to set the DECL_CONTEXT. */
13652           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13653             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13654           /* And make sure we have enough default args.  */
13655           check_default_args (decl1);
13656         }
13657       fntype = TREE_TYPE (decl1);
13658     }
13659
13660   /* Reset these in case the call to pushdecl changed them.  */
13661   current_function_decl = decl1;
13662   cfun->decl = decl1;
13663
13664   /* Initialize the per-function data.  */
13665   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13666     {
13667       /* If we already parsed this function, and we're just expanding it
13668          now, restore saved state.  */
13669       struct binding_level *bl = current_binding_level;
13670       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13671       current_binding_level = bl;
13672
13673       /* This function is being processed in whole-function mode; we
13674          already did semantic analysis.  */
13675       cfun->x_whole_function_mode_p = 1;
13676
13677       /* If we decided that we didn't want to inline this function,
13678          make sure the back-end knows that.  */
13679       if (!current_function_cannot_inline)
13680         current_function_cannot_inline = cp_function_chain->cannot_inline;
13681
13682       /* We don't need the saved data anymore.  */
13683       free (DECL_SAVED_FUNCTION_DATA (decl1));
13684       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13685     }
13686   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13687     {
13688       /* We know that this was set up by `grokclassfn'.  We do not
13689          wait until `store_parm_decls', since evil parse errors may
13690          never get us to that point.  Here we keep the consistency
13691          between `current_class_type' and `current_class_ptr'.  */
13692       tree t = DECL_ARGUMENTS (decl1);
13693
13694       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13695                           162);
13696       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13697                           19990811);
13698
13699       cp_function_chain->x_current_class_ref
13700         = build_indirect_ref (t, NULL_PTR);
13701       cp_function_chain->x_current_class_ptr = t;
13702
13703       /* Constructors and destructors need to know whether they're "in
13704          charge" of initializing virtual base classes.  */
13705       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13706         current_in_charge_parm = TREE_CHAIN (t);
13707     }
13708
13709   if (DECL_INTERFACE_KNOWN (decl1))
13710     {
13711       tree ctx = decl_function_context (decl1);
13712
13713       if (DECL_NOT_REALLY_EXTERN (decl1))
13714         DECL_EXTERNAL (decl1) = 0;
13715
13716       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13717           && TREE_PUBLIC (ctx))
13718         /* This is a function in a local class in an extern inline
13719            function.  */
13720         comdat_linkage (decl1);
13721     }
13722   /* If this function belongs to an interface, it is public.
13723      If it belongs to someone else's interface, it is also external.
13724      This only affects inlines and template instantiations.  */
13725   else if (interface_unknown == 0
13726            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13727                || flag_alt_external_templates))
13728     {
13729       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13730           || processing_template_decl)
13731         {
13732           DECL_EXTERNAL (decl1)
13733             = (interface_only
13734                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13735                    && !DECL_VINDEX (decl1)));
13736
13737           /* For WIN32 we also want to put these in linkonce sections.  */
13738           maybe_make_one_only (decl1);
13739         }
13740       else
13741         DECL_EXTERNAL (decl1) = 0;
13742       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13743       DECL_INTERFACE_KNOWN (decl1) = 1;
13744     }
13745   else if (interface_unknown && interface_only
13746            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13747                || flag_alt_external_templates))
13748     {
13749       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13750          interface, we will have interface_only set but not
13751          interface_known.  In that case, we don't want to use the normal
13752          heuristics because someone will supply a #pragma implementation
13753          elsewhere, and deducing it here would produce a conflict.  */
13754       comdat_linkage (decl1);
13755       DECL_EXTERNAL (decl1) = 0;
13756       DECL_INTERFACE_KNOWN (decl1) = 1;
13757       DECL_DEFER_OUTPUT (decl1) = 1;
13758     }
13759   else
13760     {
13761       /* This is a definition, not a reference.
13762          So clear DECL_EXTERNAL.  */
13763       DECL_EXTERNAL (decl1) = 0;
13764
13765       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13766           && ! DECL_INTERFACE_KNOWN (decl1)
13767           /* Don't try to defer nested functions for now.  */
13768           && ! decl_function_context (decl1))
13769         DECL_DEFER_OUTPUT (decl1) = 1;
13770       else
13771         DECL_INTERFACE_KNOWN (decl1) = 1;
13772     }
13773
13774   if (doing_semantic_analysis_p ())
13775     {
13776       pushlevel (0);
13777       current_binding_level->parm_flag = 1;
13778     }
13779
13780   if (attrs)
13781     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13782
13783   if (!building_stmt_tree ())
13784     {
13785       GNU_xref_function (decl1, current_function_parms);
13786       make_function_rtl (decl1);
13787     }
13788
13789   /* Promote the value to int before returning it.  */
13790   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13791     restype = type_promotes_to (restype);
13792
13793   /* If this fcn was already referenced via a block-scope `extern' decl
13794      (or an implicit decl), propagate certain information about the usage.  */
13795   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13796     TREE_ADDRESSABLE (decl1) = 1;
13797
13798   if (DECL_RESULT (decl1) == NULL_TREE)
13799     {
13800       DECL_RESULT (decl1)
13801         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13802       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13803       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13804     }
13805
13806   ++function_depth;
13807
13808   if (DECL_DESTRUCTOR_P (decl1))
13809     {
13810       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13811       DECL_CONTEXT (dtor_label) = current_function_decl;
13812     }
13813   /* Under the old ABI we return `this' from constructors, so we make
13814      ordinary `return' statements in constructors jump to CTOR_LABEL;
13815      from there we return `this'.  Under the new ABI, we don't bother
13816      with any of this.  By not setting CTOR_LABEL the remainder of the
13817      machinery is automatically disabled.  */
13818   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13819     {
13820       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13821       DECL_CONTEXT (ctor_label) = current_function_decl;
13822     }
13823
13824   return 1;
13825 }
13826 \f
13827 /* Called after store_parm_decls for a function-try-block.  */
13828
13829 void
13830 expand_start_early_try_stmts ()
13831 {
13832   expand_start_try_stmts ();
13833 }
13834
13835 /* Store the parameter declarations into the current function declaration.
13836    This is called after parsing the parameter declarations, before
13837    digesting the body of the function.
13838
13839    Also install to binding contour return value identifier, if any.  */
13840
13841 void
13842 store_parm_decls ()
13843 {
13844   register tree fndecl = current_function_decl;
13845   register tree parm;
13846   int parms_have_cleanups = 0;
13847   tree cleanups = NULL_TREE;
13848
13849   /* This is a list of types declared among parms in a prototype.  */
13850   tree parmtags = current_function_parm_tags;
13851
13852   /* This is a chain of any other decls that came in among the parm
13853      declarations.  If a parm is declared with  enum {foo, bar} x;
13854      then CONST_DECLs for foo and bar are put here.  */
13855   tree nonparms = NULL_TREE;
13856
13857   /* Create a binding level for the parms.  */
13858   if (!building_stmt_tree ())
13859     expand_start_bindings (2);
13860
13861   if (current_function_parms)
13862     {
13863       /* This case is when the function was defined with an ANSI prototype.
13864          The parms already have decls, so we need not do anything here
13865          except record them as in effect
13866          and complain if any redundant old-style parm decls were written.  */
13867
13868       tree specparms = current_function_parms;
13869       tree next;
13870
13871       if (doing_semantic_analysis_p ())
13872         {
13873           /* Must clear this because it might contain TYPE_DECLs declared
13874              at class level.  */
13875           storedecls (NULL_TREE);
13876
13877           /* If we're doing semantic analysis, then we'll call pushdecl
13878              for each of these.  We must do them in reverse order so that
13879              they end in the correct forward order.  */
13880           specparms = nreverse (specparms);
13881         }
13882
13883       for (parm = specparms; parm; parm = next)
13884         {
13885           next = TREE_CHAIN (parm);
13886           if (TREE_CODE (parm) == PARM_DECL)
13887             {
13888               tree type = TREE_TYPE (parm);
13889
13890               if (doing_semantic_analysis_p ())
13891                 {
13892                   tree cleanup;
13893
13894                   if (DECL_NAME (parm) == NULL_TREE
13895                       || TREE_CODE (parm) != VOID_TYPE)
13896                     pushdecl (parm);
13897                   else
13898                     cp_error ("parameter `%D' declared void", parm);
13899
13900                   cleanup = (processing_template_decl
13901                              ? NULL_TREE
13902                              : maybe_build_cleanup (parm));
13903
13904                   if (cleanup)
13905                     cleanups = tree_cons (parm, cleanup, cleanups);
13906                 }
13907               else if (type != error_mark_node
13908                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13909                 parms_have_cleanups = 1;
13910             }
13911           else
13912             {
13913               /* If we find an enum constant or a type tag,
13914                  put it aside for the moment.  */
13915               TREE_CHAIN (parm) = NULL_TREE;
13916               nonparms = chainon (nonparms, parm);
13917             }
13918         }
13919
13920       if (doing_semantic_analysis_p ())
13921         {
13922           /* Get the decls in their original chain order
13923              and record in the function.  This is all and only the
13924              PARM_DECLs that were pushed into scope by the loop above.  */
13925           DECL_ARGUMENTS (fndecl) = getdecls ();
13926           storetags (chainon (parmtags, gettags ()));
13927         }
13928     }
13929   else
13930     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13931
13932   /* Now store the final chain of decls for the arguments
13933      as the decl-chain of the current lexical scope.
13934      Put the enumerators in as well, at the front so that
13935      DECL_ARGUMENTS is not modified.  */
13936   if (doing_semantic_analysis_p ())
13937     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13938
13939   /* Initialize the RTL code for the function.  */
13940   DECL_SAVED_INSNS (fndecl) = 0;
13941   if (! building_stmt_tree ())
13942     expand_function_start (fndecl, parms_have_cleanups);
13943
13944   current_function_parms_stored = 1;
13945
13946   /* If this function is `main', emit a call to `__main'
13947      to run global initializers, etc.  */
13948   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13949     expand_main_function ();
13950
13951   /* Now that we have initialized the parms, we can start their
13952      cleanups.  We cannot do this before, since expand_decl_cleanup
13953      should not be called before the parm can be used.  */
13954   while (cleanups)
13955     {
13956       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13957                            TREE_VALUE (cleanups));
13958       cleanups = TREE_CHAIN (cleanups);
13959     }
13960
13961   /* Create a binding contour which can be used to catch
13962      cleanup-generated temporaries.  Also, if the return value needs or
13963      has initialization, deal with that now.  */
13964   if (parms_have_cleanups)
13965     {
13966       pushlevel (0);
13967       if (!building_stmt_tree ())
13968         expand_start_bindings (2);
13969     }
13970
13971   /* Do the starting of the exception specifications, if we have any.  */
13972   if (flag_exceptions && !processing_template_decl
13973       && flag_enforce_eh_specs
13974       && building_stmt_tree ()
13975       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13976     current_eh_spec_try_block = expand_start_eh_spec ();
13977 }
13978
13979 /* Bind a name and initialization to the return value of
13980    the current function.  */
13981
13982 void
13983 store_return_init (decl)
13984      tree decl;
13985 {
13986   /* If this named return value comes in a register, put it in a
13987      pseudo-register.  */
13988   if (DECL_REGISTER (decl))
13989     {
13990       original_result_rtx = DECL_RTL (decl);
13991       /* Note that the mode of the old DECL_RTL may be wider than the
13992          mode of DECL_RESULT, depending on the calling conventions for
13993          the processor.  For example, on the Alpha, a 32-bit integer
13994          is returned in a DImode register -- the DECL_RESULT has
13995          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
13996          here, we use the mode the back-end has already assigned for
13997          the return value.  */
13998       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13999       if (TREE_ADDRESSABLE (decl))
14000         put_var_into_stack (decl);
14001     }
14002 }
14003
14004 \f
14005 /* We have finished doing semantic analysis on DECL, but have not yet
14006    generated RTL for its body.  Save away our current state, so that
14007    when we want to generate RTL later we know what to do.  */
14008
14009 static void
14010 save_function_data (decl)
14011      tree decl;
14012 {
14013   struct language_function *f;
14014
14015   /* Save the language-specific per-function data so that we can
14016      get it back when we really expand this function.  */
14017   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14018                       19990908);
14019
14020   /* Make a copy.  */
14021   f = ((struct language_function *)
14022        xmalloc (sizeof (struct language_function)));
14023   bcopy ((char *) cp_function_chain, (char *) f,
14024          sizeof (struct language_function));
14025   DECL_SAVED_FUNCTION_DATA (decl) = f;
14026
14027   /* Clear out the bits we don't need.  */
14028   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14029   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14030   f->x_result_rtx = NULL_RTX;
14031   f->x_named_label_uses = NULL;
14032   f->bindings = NULL;
14033
14034   /* When we get back here again, we will be expanding.  */
14035   f->x_expanding_p = 1;
14036
14037   /* If we've already decided that we cannot inline this function, we
14038      must remember that fact when we actually go to expand the
14039      function.  */
14040   f->cannot_inline = current_function_cannot_inline;
14041 }
14042
14043 /* At the end of every constructor we generate to code to return
14044    `this'.  Do that now.  */
14045
14046 static void
14047 finish_constructor_body ()
14048 {
14049   /* Any return from a constructor will end up here.  */
14050   if (ctor_label)
14051     add_tree (build_stmt (LABEL_STMT, ctor_label));
14052
14053   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14054      generate the return, rather than a goto to CTOR_LABEL.  */
14055   ctor_label = NULL_TREE;
14056   /* In check_return_expr we translate an empty return from a
14057      constructor to a return of `this'.  */
14058   finish_return_stmt (NULL_TREE);
14059   /* Mark the end of the constructor.  */
14060   add_tree (build_stmt (CTOR_STMT));
14061 }
14062
14063 /* At the end of every destructor we generate code to restore virtual
14064    function tables to the values desired by base classes and to call
14065    to base class destructors.  Do that now.  */
14066
14067 static void
14068 finish_destructor_body ()
14069 {
14070   tree compound_stmt;
14071   tree virtual_size;
14072   tree exprstmt;
14073   tree if_stmt;
14074
14075   /* Create a block to contain all the extra code.  */
14076   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14077
14078   /* Any return from a destructor will end up here.  */
14079   add_tree (build_stmt (LABEL_STMT, dtor_label));
14080
14081   /* Generate the code to call destructor on base class.  If this
14082      destructor belongs to a class with virtual functions, then set
14083      the virtual function table pointer to represent the type of our
14084      base class.  */
14085
14086   /* This side-effect makes call to `build_delete' generate the code
14087      we have to have at the end of this destructor.  `build_delete'
14088      will set the flag again.  */
14089   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14090
14091   exprstmt = build_delete (current_class_type,
14092                            current_class_ref,
14093                            sfk_base_destructor,
14094                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14095                            0);
14096
14097   if (exprstmt != error_mark_node
14098       && (TREE_CODE (exprstmt) != NOP_EXPR
14099           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14100           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14101     {
14102       if (exprstmt != void_zero_node)
14103         /* Don't call `expand_expr_stmt' if we're not going to do
14104            anything, since -Wall will give a diagnostic.  */
14105         finish_expr_stmt (exprstmt);
14106
14107       /* Run destructors for all virtual baseclasses.  */
14108       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14109         {
14110           tree vbases;
14111           tree if_stmt;
14112
14113           if_stmt = begin_if_stmt ();
14114           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14115                                       current_in_charge_parm,
14116                                       integer_two_node),
14117                                if_stmt);
14118
14119           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14120           /* The CLASSTYPE_VBASECLASSES list is in initialization
14121              order, so we have to march through it in reverse order.  */
14122           for (vbases = nreverse (copy_list (vbases));
14123                vbases;
14124                vbases = TREE_CHAIN (vbases))
14125             {
14126               tree vbase = TREE_VALUE (vbases);
14127
14128               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14129                 {
14130                   tree vb = get_vbase
14131                     (BINFO_TYPE (vbase),
14132                      TYPE_BINFO (current_class_type));
14133                   finish_expr_stmt
14134                     (build_scoped_method_call
14135                      (current_class_ref, vb, base_dtor_identifier,
14136                       NULL_TREE));
14137                 }
14138             }
14139
14140           finish_then_clause (if_stmt);
14141           finish_if_stmt ();
14142         }
14143     }
14144
14145   virtual_size = c_sizeof (current_class_type);
14146
14147   /* At the end, call delete if that's what's requested.  */
14148
14149   /* FDIS sez: At the point of definition of a virtual destructor
14150      (including an implicit definition), non-placement operator delete
14151      shall be looked up in the scope of the destructor's class and if
14152      found shall be accessible and unambiguous.
14153
14154      This is somewhat unclear, but I take it to mean that if the class
14155      only defines placement deletes we don't do anything here.  So we
14156      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14157      they ever try to delete one of these.  */
14158   exprstmt = build_op_delete_call
14159     (DELETE_EXPR, current_class_ptr, virtual_size,
14160      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14161
14162   if_stmt = begin_if_stmt ();
14163   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14164                               current_in_charge_parm,
14165                               integer_one_node),
14166                        if_stmt);
14167   finish_expr_stmt (exprstmt);
14168   finish_then_clause (if_stmt);
14169   finish_if_stmt ();
14170
14171   /* Close the block we started above.  */
14172   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14173 }
14174
14175 /* Finish up a function declaration and compile that function
14176    all the way to assembler language output.  The free the storage
14177    for the function definition.
14178
14179    FLAGS is a bitwise or of the following values:
14180      1 - CALL_POPLEVEL
14181        An extra call to poplevel (and expand_end_bindings) must be
14182        made to take care of the binding contour for the base
14183        initializers.  This is only relevant for constructors.
14184      2 - INCLASS_INLINE
14185        We just finished processing the body of an in-class inline
14186        function definition.  (This processing will have taken place
14187        after the class definition is complete.)  */
14188
14189 tree
14190 finish_function (flags)
14191      int flags;
14192 {
14193   register tree fndecl = current_function_decl;
14194   tree fntype, ctype = NULL_TREE;
14195   /* Label to use if this function is supposed to return a value.  */
14196   tree no_return_label = NULL_TREE;
14197   int call_poplevel = (flags & 1) != 0;
14198   int inclass_inline = (flags & 2) != 0;
14199   int expand_p;
14200   int nested;
14201   int current_line = lineno;
14202
14203   /* When we get some parse errors, we can end up without a
14204      current_function_decl, so cope.  */
14205   if (fndecl == NULL_TREE)
14206     return error_mark_node;
14207
14208   nested = function_depth > 1;
14209   fntype = TREE_TYPE (fndecl);
14210
14211   /*  TREE_READONLY (fndecl) = 1;
14212       This caused &foo to be of type ptr-to-const-function
14213       which then got a warning when stored in a ptr-to-function variable.  */
14214
14215   /* This happens on strange parse errors.  */
14216   if (! current_function_parms_stored)
14217     {
14218       call_poplevel = 0;
14219       store_parm_decls ();
14220     }
14221
14222   /* For a cloned function, we've already got all the code we need;
14223      there's no need to add any extra bits.  */
14224   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14225     ;
14226   else if (building_stmt_tree ())
14227     {
14228       if (DECL_CONSTRUCTOR_P (fndecl))
14229         {
14230           finish_constructor_body ();
14231           if (call_poplevel)
14232             do_poplevel ();
14233         }
14234       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14235         finish_destructor_body ();
14236       else if (DECL_MAIN_P (fndecl))
14237         {
14238           /* Make it so that `main' always returns 0 by default.  */
14239 #ifdef VMS
14240           finish_return_stmt (integer_one_node);
14241 #else
14242           finish_return_stmt (integer_zero_node);
14243 #endif
14244         }
14245
14246       /* Finish dealing with exception specifiers.  */
14247       if (flag_exceptions && !processing_template_decl
14248           && flag_enforce_eh_specs
14249           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14250         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14251                             (TREE_TYPE (current_function_decl)),
14252                             current_eh_spec_try_block);
14253     }
14254   else
14255     {
14256 #if 0
14257       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14258         {
14259           /* Keep this code around in case we later want to control debug info
14260              based on whether a type is "used".  (jason 1999-11-11) */
14261
14262           tree ttype = target_type (fntype);
14263           tree parmdecl;
14264
14265           if (IS_AGGR_TYPE (ttype))
14266             /* Let debugger know it should output info for this type.  */
14267             note_debug_info_needed (ttype);
14268
14269           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14270             {
14271               ttype = target_type (TREE_TYPE (parmdecl));
14272               if (IS_AGGR_TYPE (ttype))
14273                 /* Let debugger know it should output info for this type.  */
14274                 note_debug_info_needed (ttype);
14275             }
14276         }
14277 #endif
14278
14279       /* Clean house because we will need to reorder insns here.  */
14280       do_pending_stack_adjust ();
14281
14282       if (dtor_label)
14283         ;
14284       else if (DECL_CONSTRUCTOR_P (fndecl))
14285         {
14286           if (call_poplevel)
14287             do_poplevel ();
14288         }
14289       else if (return_label != NULL_RTX
14290                && flag_this_is_variable <= 0
14291                && current_function_return_value == NULL_TREE
14292                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14293         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14294
14295       if (flag_exceptions)
14296         expand_exception_blocks ();
14297
14298       /* If this function is supposed to return a value, ensure that
14299          we do not fall into the cleanups by mistake.  The end of our
14300          function will look like this:
14301
14302          user code (may have return stmt somewhere)
14303          goto no_return_label
14304          cleanup_label:
14305          cleanups
14306          goto return_label
14307          no_return_label:
14308          NOTE_INSN_FUNCTION_END
14309          return_label:
14310          things for return
14311
14312          If the user omits a return stmt in the USER CODE section, we
14313          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14314          Otherwise, we won't.  */
14315       if (no_return_label)
14316         {
14317           DECL_CONTEXT (no_return_label) = fndecl;
14318           DECL_INITIAL (no_return_label) = error_mark_node;
14319           DECL_SOURCE_FILE (no_return_label) = input_filename;
14320           DECL_SOURCE_LINE (no_return_label) = current_line;
14321           expand_goto (no_return_label);
14322         }
14323
14324       if (cleanup_label)
14325         {
14326           /* Remove the binding contour which is used
14327              to catch cleanup-generated temporaries.  */
14328           expand_end_bindings (0, 0, 0);
14329           poplevel (0, 0, 0);
14330
14331           /* Emit label at beginning of cleanup code for parameters.  */
14332           emit_label (cleanup_label);
14333         }
14334
14335       /* Get return value into register if that's where it's supposed
14336          to be.  */
14337       if (original_result_rtx)
14338         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14339
14340       /* Finish building code that will trigger warnings if users forget
14341          to make their functions return values.  */
14342       if (no_return_label || cleanup_label)
14343         emit_jump (return_label);
14344       if (no_return_label)
14345         {
14346           /* We don't need to call `expand_*_return' here because we
14347              don't need any cleanups here--this path of code is only
14348              for error checking purposes.  */
14349           expand_label (no_return_label);
14350         }
14351
14352       /* We hard-wired immediate_size_expand to zero in
14353          start_function.  Expand_function_end will decrement this
14354          variable.  So, we set the variable to one here, so that after
14355          the decrement it will remain zero.  */
14356       immediate_size_expand = 1;
14357
14358       /* Generate rtl for function exit.  */
14359       expand_function_end (input_filename, current_line, 1);
14360     }
14361
14362   /* We have to save this value here in case
14363      maybe_end_member_template_processing decides to pop all the
14364      template parameters.  */
14365   expand_p = !building_stmt_tree ();
14366
14367   /* If we're saving up tree structure, tie off the function now.  */
14368   if (!expand_p)
14369     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14370
14371   /* This must come after expand_function_end because cleanups might
14372      have declarations (from inline functions) that need to go into
14373      this function's blocks.  */
14374   if (doing_semantic_analysis_p ())
14375     {
14376       if (current_binding_level->parm_flag != 1)
14377         my_friendly_abort (122);
14378       poplevel (1, 0, 1);
14379     }
14380
14381   /* Remember that we were in class scope.  */
14382   if (current_class_name)
14383     ctype = current_class_type;
14384
14385   /* Must mark the RESULT_DECL as being in this function.  */
14386   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14387
14388   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14389      to the FUNCTION_DECL node itself.  */
14390   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14391
14392   /* Save away current state, if appropriate.  */
14393   if (!expanding_p && !processing_template_decl)
14394     save_function_data (fndecl);
14395
14396   /* If this function calls `setjmp' it cannot be inlined.  When
14397      `longjmp' is called it is not guaranteed to restore the value of
14398      local variables that have been modified since the call to
14399      `setjmp'.  So, if were to inline this function into some caller
14400      `c', then when we `longjmp', we might not restore all variables
14401      in `c'.  (It might seem, at first blush, that there's no way for
14402      this function to modify local variables in `c', but their
14403      addresses may have been stored somewhere accessible to this
14404      function.)  */
14405   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14406     DECL_UNINLINABLE (fndecl) = 1;
14407
14408   if (expand_p)
14409     {
14410       int returns_null;
14411       int returns_value;
14412
14413       /* So we can tell if jump_optimize sets it to 1.  */
14414       can_reach_end = 0;
14415
14416       /* Before we call rest_of_compilation (which will pop the
14417          CURRENT_FUNCTION), we must save these values.  */
14418       returns_null = current_function_returns_null;
14419       returns_value = current_function_returns_value;
14420
14421       /* If this is a nested function (like a template instantiation
14422          that we're compiling in the midst of compiling something
14423          else), push a new GC context.  That will keep local variables
14424          on the stack from being collected while we're doing the
14425          compilation of this function.  */
14426       if (function_depth > 1)
14427         ggc_push_context ();
14428
14429       /* Run the optimizers and output the assembler code for this
14430          function.  */
14431       rest_of_compilation (fndecl);
14432
14433       /* Undo the call to ggc_push_context above.  */
14434       if (function_depth > 1)
14435         ggc_pop_context ();
14436
14437       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14438         {
14439           /* Set DECL_EXTERNAL so that assemble_external will be called as
14440              necessary.  We'll clear it again in finish_file.  */
14441           if (! DECL_EXTERNAL (fndecl))
14442             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14443           DECL_EXTERNAL (fndecl) = 1;
14444           defer_fn (fndecl);
14445         }
14446
14447 #if 0
14448       /* Keep this code around in case we later want to control debug info
14449          based on whether a type is "used".  (jason 1999-11-11) */
14450
14451       if (ctype && TREE_ASM_WRITTEN (fndecl))
14452         note_debug_info_needed (ctype);
14453 #endif
14454
14455       if (DECL_NAME (DECL_RESULT (fndecl)))
14456         returns_value |= can_reach_end;
14457       else
14458         returns_null |= can_reach_end;
14459
14460       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14461         warning ("`noreturn' function does return");
14462       else if (returns_null
14463                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14464         {
14465           /* Always complain if there's just no return statement.  */
14466           if (!returns_value)
14467             warning ("no return statement in function returning non-void");
14468           else if (warn_return_type || pedantic)
14469             /* If this function returns non-void and control can drop through,
14470                complain.  */
14471             warning ("control reaches end of non-void function");
14472         }
14473     }
14474   else
14475     {
14476       /* Clear out memory we no longer need.  */
14477       free_after_parsing (cfun);
14478       /* Since we never call rest_of_compilation, we never clear
14479          CFUN.  Do so explicitly.  */
14480       free_after_compilation (cfun);
14481       cfun = NULL;
14482     }
14483
14484   /* If this is a in-class inline definition, we may have to pop the
14485      bindings for the template parameters that we added in
14486      maybe_begin_member_template_processing when start_function was
14487      called.  */
14488   if (inclass_inline)
14489     maybe_end_member_template_processing ();
14490
14491   /* Leave the scope of the class.  */
14492   if (ctype)
14493     pop_nested_class ();
14494
14495   --function_depth;
14496
14497   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14498       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14499     {
14500       tree t;
14501
14502       /* Stop pointing to the local nodes about to be freed.  */
14503       /* But DECL_INITIAL must remain nonzero so we know this
14504          was an actual function definition.  */
14505       DECL_INITIAL (fndecl) = error_mark_node;
14506       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14507         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14508     }
14509
14510   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14511     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14512   if (DECL_STATIC_DESTRUCTOR (fndecl))
14513     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14514
14515   /* Clean up.  */
14516   if (! nested)
14517     {
14518       /* Let the error reporting routines know that we're outside a
14519          function.  For a nested function, this value is used in
14520          pop_cp_function_context and then reset via pop_function_context.  */
14521       current_function_decl = NULL_TREE;
14522       /* We don't really care about obstacks, but the middle-end
14523          sometimes cares on what obstck things are located.  */
14524       permanent_allocation (1);
14525     }
14526
14527   return fndecl;
14528 }
14529 \f
14530 /* Create the FUNCTION_DECL for a function definition.
14531    DECLSPECS and DECLARATOR are the parts of the declaration;
14532    they describe the return type and the name of the function,
14533    but twisted together in a fashion that parallels the syntax of C.
14534
14535    This function creates a binding context for the function body
14536    as well as setting up the FUNCTION_DECL in current_function_decl.
14537
14538    Returns a FUNCTION_DECL on success.
14539
14540    If the DECLARATOR is not suitable for a function (it defines a datum
14541    instead), we return 0, which tells yyparse to report a parse error.
14542
14543    May return void_type_node indicating that this method is actually
14544    a friend.  See grokfield for more details.
14545
14546    Came here with a `.pushlevel' .
14547
14548    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14549    CHANGES TO CODE IN `grokfield'.  */
14550
14551 tree
14552 start_method (declspecs, declarator, attrlist)
14553      tree declarator, declspecs, attrlist;
14554 {
14555   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14556                                 attrlist);
14557
14558   /* Something too ugly to handle.  */
14559   if (fndecl == NULL_TREE)
14560     return NULL_TREE;
14561
14562   /* Pass friends other than inline friend functions back.  */
14563   if (fndecl == void_type_node)
14564     return fndecl;
14565
14566   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14567     /* Not a function, tell parser to report parse error.  */
14568     return NULL_TREE;
14569
14570   if (DECL_IN_AGGR_P (fndecl))
14571     {
14572       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14573         {
14574           if (DECL_CONTEXT (fndecl)
14575               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14576             cp_error ("`%D' is already defined in class %s", fndecl,
14577                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14578         }
14579       return void_type_node;
14580     }
14581
14582   check_template_shadow (fndecl);
14583
14584   DECL_THIS_INLINE (fndecl) = 1;
14585
14586   if (flag_default_inline)
14587     DECL_INLINE (fndecl) = 1;
14588
14589   /* We process method specializations in finish_struct_1.  */
14590   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14591     fndecl = push_template_decl (fndecl);
14592
14593   if (! DECL_FRIEND_P (fndecl))
14594     {
14595       if (TREE_CHAIN (fndecl))
14596         {
14597           fndecl = copy_node (fndecl);
14598           TREE_CHAIN (fndecl) = NULL_TREE;
14599         }
14600
14601       if (DECL_CONSTRUCTOR_P (fndecl))
14602         {
14603           if (! grok_ctor_properties (current_class_type, fndecl))
14604             return void_type_node;
14605         }
14606       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14607         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14608     }
14609
14610   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14611
14612   /* Make a place for the parms */
14613   pushlevel (0);
14614   current_binding_level->parm_flag = 1;
14615
14616   DECL_IN_AGGR_P (fndecl) = 1;
14617   return fndecl;
14618 }
14619
14620 /* Go through the motions of finishing a function definition.
14621    We don't compile this method until after the whole class has
14622    been processed.
14623
14624    FINISH_METHOD must return something that looks as though it
14625    came from GROKFIELD (since we are defining a method, after all).
14626
14627    This is called after parsing the body of the function definition.
14628    STMTS is the chain of statements that makes up the function body.
14629
14630    DECL is the ..._DECL that `start_method' provided.  */
14631
14632 tree
14633 finish_method (decl)
14634      tree decl;
14635 {
14636   register tree fndecl = decl;
14637   tree old_initial;
14638
14639   register tree link;
14640
14641   if (decl == void_type_node)
14642     return decl;
14643
14644   old_initial = DECL_INITIAL (fndecl);
14645
14646   /* Undo the level for the parms (from start_method).
14647      This is like poplevel, but it causes nothing to be
14648      saved.  Saving information here confuses symbol-table
14649      output routines.  Besides, this information will
14650      be correctly output when this method is actually
14651      compiled.  */
14652
14653   /* Clear out the meanings of the local variables of this level;
14654      also record in each decl which block it belongs to.  */
14655
14656   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14657     {
14658       if (DECL_NAME (link) != NULL_TREE)
14659         pop_binding (DECL_NAME (link), link);
14660       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14661       DECL_CONTEXT (link) = NULL_TREE;
14662     }
14663
14664   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14665                       (HOST_WIDE_INT) current_binding_level->level_chain,
14666                       current_binding_level->parm_flag,
14667                       current_binding_level->keep);
14668
14669   poplevel (0, 0, 0);
14670
14671   DECL_INITIAL (fndecl) = old_initial;
14672
14673   /* We used to check if the context of FNDECL was different from
14674      current_class_type as another way to get inside here.  This didn't work
14675      for String.cc in libg++.  */
14676   if (DECL_FRIEND_P (fndecl))
14677     {
14678       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14679         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14680       decl = void_type_node;
14681     }
14682
14683   return decl;
14684 }
14685 \f
14686 /* Called when a new struct TYPE is defined.
14687    If this structure or union completes the type of any previous
14688    variable declaration, lay it out and output its rtl.  */
14689
14690 void
14691 hack_incomplete_structures (type)
14692      tree type;
14693 {
14694   tree *list;
14695   struct binding_level *level;
14696
14697   if (!type) /* Don't do this for class templates.  */
14698     return;
14699
14700   if (namespace_bindings_p ())
14701     {
14702       level = 0;
14703       list = &namespace_scope_incomplete;
14704     }
14705   else
14706     {
14707       level = innermost_nonclass_level ();
14708       list = &level->incomplete;
14709     }
14710
14711   while (1)
14712     {
14713       while (*list)
14714         {
14715           tree decl = TREE_VALUE (*list);
14716           if ((decl && TREE_TYPE (decl) == type)
14717               || (TREE_TYPE (decl)
14718                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14719                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14720             {
14721               int toplevel = toplevel_bindings_p ();
14722               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14723                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14724                 layout_type (TREE_TYPE (decl));
14725               layout_decl (decl, 0);
14726               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14727               if (! toplevel)
14728                 {
14729                   tree cleanup;
14730                   expand_decl (decl);
14731                   cleanup = maybe_build_cleanup (decl);
14732                   expand_decl_init (decl);
14733                   if (! expand_decl_cleanup (decl, cleanup))
14734                     cp_error ("parser lost in parsing declaration of `%D'",
14735                               decl);
14736                 }
14737               *list = TREE_CHAIN (*list);
14738             }
14739           else
14740             list = &TREE_CHAIN (*list);
14741         }
14742
14743       /* Keep looking through artificial binding levels generated
14744          for local variables.  */
14745       if (level && level->keep == 2)
14746         {
14747           level = level->level_chain;
14748           list = &level->incomplete;
14749         }
14750       else
14751         break;
14752     }
14753 }
14754
14755 /* If DECL is of a type which needs a cleanup, build that cleanup
14756    here.  */
14757
14758 tree
14759 maybe_build_cleanup (decl)
14760      tree decl;
14761 {
14762   tree type = TREE_TYPE (decl);
14763
14764   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14765     {
14766       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14767       tree rval;
14768
14769       if (TREE_CODE (type) == ARRAY_TYPE)
14770         rval = decl;
14771       else
14772         {
14773           mark_addressable (decl);
14774           rval = build_unary_op (ADDR_EXPR, decl, 0);
14775         }
14776
14777       /* Optimize for space over speed here.  */
14778       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14779           || flag_expensive_optimizations)
14780         flags |= LOOKUP_NONVIRTUAL;
14781
14782       rval = build_delete (TREE_TYPE (rval), rval,
14783                            sfk_complete_destructor, flags, 0);
14784
14785       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14786           && ! TYPE_HAS_DESTRUCTOR (type))
14787         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14788                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14789
14790       return rval;
14791     }
14792   return 0;
14793 }
14794 \f
14795 /* Expand a C++ expression at the statement level.
14796    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14797    The C++ type checker should get all of these out when
14798    expressions are combined with other, type-providing, expressions,
14799    leaving only orphan expressions, such as:
14800
14801    &class::bar;         / / takes its address, but does nothing with it.  */
14802
14803 void
14804 cplus_expand_expr_stmt (exp)
14805      tree exp;
14806 {
14807 #if 0
14808   /* We should do this eventually, but right now this causes regex.o from
14809      libg++ to miscompile, and tString to core dump.  */
14810   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14811 #endif
14812
14813   /* If we don't do this, we end up down inside expand_expr
14814      trying to do TYPE_MODE on the ERROR_MARK, and really
14815      go outside the bounds of the type.  */
14816   if (exp != error_mark_node)
14817     expand_expr_stmt (exp);
14818 }
14819
14820 /* When a stmt has been parsed, this function is called.  */
14821
14822 void
14823 finish_stmt ()
14824 {
14825   /* Always assume this statement was not an expression statement.  If
14826      it actually was an expression statement, its our callers
14827      responsibility to fix this up.  */
14828   last_expr_type = NULL_TREE;
14829 }
14830
14831 /* DECL was originally constructed as a non-static member function,
14832    but turned out to be static.  Update it accordingly.  */
14833
14834 void
14835 revert_static_member_fn (decl)
14836      tree decl;
14837 {
14838   tree tmp;
14839   tree function = TREE_TYPE (decl);
14840   tree args = TYPE_ARG_TYPES (function);
14841
14842   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14843       != TYPE_UNQUALIFIED)
14844     cp_error ("static member function `%#D' declared with type qualifiers",
14845               *decl);
14846
14847   args = TREE_CHAIN (args);
14848   tmp = build_function_type (TREE_TYPE (function), args);
14849   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14850   tmp = build_exception_variant (tmp,
14851                                  TYPE_RAISES_EXCEPTIONS (function));
14852   TREE_TYPE (decl) = tmp;
14853   if (DECL_ARGUMENTS (decl))
14854     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14855   DECL_STATIC_FUNCTION_P (decl) = 1;
14856 }
14857
14858 /* Initialize the variables used during compilation of a C++
14859    function.  */
14860
14861 static void
14862 push_cp_function_context (f)
14863      struct function *f;
14864 {
14865   struct language_function *p
14866     = ((struct language_function *)
14867        xcalloc (1, sizeof (struct language_function)));
14868   f->language = p;
14869
14870   /* It takes an explicit call to expand_body to generate RTL for a
14871      function.  */
14872   expanding_p = 0;
14873
14874   /* Whenever we start a new function, we destroy temporaries in the
14875      usual way.  */
14876   current_stmt_tree->stmts_are_full_exprs_p = 1;
14877 }
14878
14879 /* Free the language-specific parts of F, now that we've finished
14880    compiling the function.  */
14881
14882 static void
14883 pop_cp_function_context (f)
14884      struct function *f;
14885 {
14886   if (f->language)
14887     free (f->language);
14888   f->language = 0;
14889 }
14890
14891 /* Mark P for GC.  */
14892
14893 static void
14894 mark_lang_function (p)
14895      struct language_function *p;
14896 {
14897   if (!p)
14898     return;
14899
14900   ggc_mark_tree (p->x_ctor_label);
14901   ggc_mark_tree (p->x_dtor_label);
14902   ggc_mark_tree (p->x_current_class_ptr);
14903   ggc_mark_tree (p->x_current_class_ref);
14904   ggc_mark_tree (p->x_eh_spec_try_block);
14905   ggc_mark_tree (p->x_scope_stmt_stack);
14906
14907   ggc_mark_rtx (p->x_result_rtx);
14908
14909   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14910   mark_stmt_tree (&p->x_stmt_tree);
14911   mark_binding_level (&p->bindings);
14912 }
14913
14914 /* Mark the language-specific data in F for GC.  */
14915
14916 static void
14917 mark_cp_function_context (f)
14918      struct function *f;
14919 {
14920   mark_lang_function (f->language);
14921 }
14922
14923 void
14924 lang_mark_false_label_stack (l)
14925      struct label_node *l;
14926 {
14927   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14928   my_friendly_assert (l == NULL, 19990904);
14929 }
14930
14931 void
14932 lang_mark_tree (t)
14933      tree t;
14934 {
14935   enum tree_code code = TREE_CODE (t);
14936   if (code == IDENTIFIER_NODE)
14937     {
14938       struct lang_identifier *li = (struct lang_identifier *) t;
14939       struct lang_id2 *li2 = li->x;
14940       ggc_mark_tree (li->namespace_bindings);
14941       ggc_mark_tree (li->bindings);
14942       ggc_mark_tree (li->class_value);
14943       ggc_mark_tree (li->class_template_info);
14944
14945       if (li2)
14946         {
14947           ggc_mark_tree (li2->label_value);
14948           ggc_mark_tree (li2->implicit_decl);
14949           ggc_mark_tree (li2->error_locus);
14950         }
14951     }
14952   else if (code == CPLUS_BINDING)
14953     {
14954       if (BINDING_HAS_LEVEL_P (t))
14955         mark_binding_level (&BINDING_LEVEL (t));
14956       else
14957         ggc_mark_tree (BINDING_SCOPE (t));
14958       ggc_mark_tree (BINDING_VALUE (t));
14959     }
14960   else if (code == OVERLOAD)
14961     ggc_mark_tree (OVL_FUNCTION (t));
14962   else if (code == TEMPLATE_PARM_INDEX)
14963     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14964   else if (TREE_CODE_CLASS (code) == 'd')
14965     {
14966       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14967
14968       if (ld)
14969         {
14970           ggc_mark (ld);
14971           if (!DECL_GLOBAL_CTOR_P (t)
14972               && !DECL_GLOBAL_DTOR_P (t)
14973               && !DECL_THUNK_P (t))
14974             ggc_mark_tree (ld->decl_flags.u2.access);
14975           else if (DECL_THUNK_P (t))
14976             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14977           ggc_mark_tree (ld->decl_flags.context);
14978           if (TREE_CODE (t) != NAMESPACE_DECL)
14979             ggc_mark_tree (ld->decl_flags.u.template_info);
14980           else
14981             mark_binding_level (&NAMESPACE_LEVEL (t));
14982           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14983             {
14984               ggc_mark_tree (ld->befriending_classes);
14985               ggc_mark_tree (ld->saved_tree);
14986               ggc_mark_tree (ld->cloned_function);
14987               if (!DECL_OVERLOADED_OPERATOR_P (t))
14988                 ggc_mark_tree (ld->u2.vtt_parm);
14989               if (TREE_CODE (t) == TYPE_DECL)
14990                 ggc_mark_tree (ld->u.sorted_fields);
14991               else if (TREE_CODE (t) == FUNCTION_DECL
14992                        && !DECL_PENDING_INLINE_P (t))
14993                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14994             }
14995         }
14996     }
14997   else if (TREE_CODE_CLASS (code) == 't')
14998     {
14999       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
15000
15001       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15002                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15003         {
15004           ggc_mark (lt);
15005           ggc_mark_tree (lt->vfields);
15006           ggc_mark_tree (lt->vbases);
15007           ggc_mark_tree (lt->tags);
15008           ggc_mark_tree (lt->size);
15009           ggc_mark_tree (lt->pure_virtuals);
15010           ggc_mark_tree (lt->friend_classes);
15011           ggc_mark_tree (lt->rtti);
15012           ggc_mark_tree (lt->methods);
15013           ggc_mark_tree (lt->template_info);
15014           ggc_mark_tree (lt->befriending_classes);
15015         }
15016       else if (lt)
15017         /* In the case of pointer-to-member function types, the
15018            TYPE_LANG_SPECIFIC is really just a tree.  */
15019         ggc_mark_tree ((tree) lt);
15020     }
15021 }