gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 92-98, 1999 Free Software Foundation, Inc.
   3    Contributed by Michael Tiemann (tiemann@cygnus.com)
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 /* Process declarations and symbol lookup for C front end.
  24    Also constructs types; the standard scalar types at initialization,
  25    and structure, union, array and enum types when they are declared.  */
  26
  27 /* ??? not all decl nodes are given the most useful possible
  28    line numbers.  For example, the CONST_DECLs for enum values.  */
  29
  30 #include "config.h"
  31 #include "system.h"
  32 #include "tree.h"
  33 #include "rtl.h"
  34 #include "flags.h"
  35 #include "cp-tree.h"
  36 #include "decl.h"
  37 #include "lex.h"
  38 #include <signal.h>
  39 #include "obstack.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 #define obstack_chunk_alloc xmalloc
  49 #define obstack_chunk_free free
  50
  51 extern struct obstack permanent_obstack;
  52
  53 extern int current_class_depth;
  54
  55 extern tree static_ctors, static_dtors;
  56
  57 extern tree global_namespace;
  58
  59 extern int (*valid_lang_attribute) PROTO ((tree, tree, tree, tree));
  60
  61 /* Use garbage collection.  */
  62
  63 int ggc_p = 1;
  64
  65 #ifndef WCHAR_UNSIGNED
  66 #define WCHAR_UNSIGNED 0
  67 #endif
  68
  69 #ifndef CHAR_TYPE_SIZE
  70 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  71 #endif
  72
  73 #ifndef BOOL_TYPE_SIZE
  74 #ifdef SLOW_BYTE_ACCESS
  75 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  76 #else
  77 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  78 #endif
  79 #endif
  80
  81 /* We let tm.h override the types used here, to handle trivial differences
  82    such as the choice of unsigned int or long unsigned int for size_t.
  83    When machines start needing nontrivial differences in the size type,
  84    it would be best to do something here to figure out automatically
  85    from other information what type to use.  */
  86
  87 #ifndef SIZE_TYPE
  88 #define SIZE_TYPE "long unsigned int"
  89 #endif
  90
  91 #ifndef PTRDIFF_TYPE
  92 #define PTRDIFF_TYPE "long int"
  93 #endif
  94
  95 #ifndef WCHAR_TYPE
  96 #define WCHAR_TYPE "int"
  97 #endif
  98
  99 static tree grokparms                           PROTO((tree, int));
 100 static const char *redeclaration_error_message  PROTO((tree, tree));
 101
 102 static void push_binding_level PROTO((struct binding_level *, int,
 103                                       int));
 104 static void pop_binding_level PROTO((void));
 105 static void suspend_binding_level PROTO((void));
 106 static void resume_binding_level PROTO((struct binding_level *));
 107 static struct binding_level *make_binding_level PROTO((void));
 108 static void declare_namespace_level PROTO((void));
 109 static void signal_catch PROTO((int)) ATTRIBUTE_NORETURN;
 110 static void storedecls PROTO((tree));
 111 static void require_complete_types_for_parms PROTO((tree));
 112 static void push_overloaded_decl_1 PROTO((tree));
 113 static int ambi_op_p PROTO((tree));
 114 static int unary_op_p PROTO((tree));
 115 static tree store_bindings PROTO((tree, tree));
 116 static tree lookup_tag_reverse PROTO((tree, tree));
 117 static tree obscure_complex_init PROTO((tree, tree));
 118 static tree maybe_build_cleanup_1 PROTO((tree, tree));
 119 static tree lookup_name_real PROTO((tree, int, int, int));
 120 static void warn_extern_redeclared_static PROTO((tree, tree));
 121 static void grok_reference_init PROTO((tree, tree, tree));
 122 static tree grokfndecl PROTO((tree, tree, tree, tree, int,
 123                               enum overload_flags, tree,
 124                               tree, int, int, int, int, int, int, tree));
 125 static tree grokvardecl PROTO((tree, tree, RID_BIT_TYPE *, int, int, tree));
 126 static tree lookup_tag PROTO((enum tree_code, tree,
 127                               struct binding_level *, int));
 128 static void set_identifier_type_value_with_scope
 129         PROTO((tree, tree, struct binding_level *));
 130 static void record_builtin_type PROTO((enum rid, const char *, tree));
 131 static void record_unknown_type PROTO((tree, const char *));
 132 static int member_function_or_else PROTO((tree, tree, const char *));
 133 static void bad_specifiers PROTO((tree, const char *, int, int, int, int,
 134                                   int));
 135 static void lang_print_error_function PROTO((const char *));
 136 static tree maybe_process_template_type_declaration PROTO((tree, int, struct binding_level*));
 137 static void check_for_uninitialized_const_var PROTO((tree));
 138 static unsigned long typename_hash PROTO((hash_table_key));
 139 static boolean typename_compare PROTO((hash_table_key, hash_table_key));
 140 static void push_binding PROTO((tree, tree, struct binding_level*));
 141 static int add_binding PROTO((tree, tree));
 142 static void pop_binding PROTO((tree, tree));
 143 static tree local_variable_p_walkfn PROTO((tree *, int *, void *));
 144 static tree find_binding PROTO((tree, tree));
 145 static tree select_decl PROTO((tree, int));
 146 static int lookup_flags PROTO((int, int));
 147 static tree qualify_lookup PROTO((tree, int));
 148 static tree record_builtin_java_type PROTO((const char *, int));
 149 static const char *tag_name PROTO((enum tag_types code));
 150 static void find_class_binding_level PROTO((void));
 151 static struct binding_level *innermost_nonclass_level PROTO((void));
 152 static void warn_about_implicit_typename_lookup PROTO((tree, tree));
 153 static int walk_namespaces_r PROTO((tree, walk_namespaces_fn, void *));
 154 static int walk_globals_r PROTO((tree, void *));
 155 static void add_decl_to_level PROTO((tree, struct binding_level *));
 156 static tree make_label_decl PROTO((tree, int));
 157 static void pop_label PROTO((tree));
 158 static void pop_labels PROTO((tree));
 159 static void maybe_deduce_size_from_array_init PROTO((tree, tree));
 160 static void layout_var_decl PROTO((tree));
 161 static void maybe_commonize_var PROTO((tree));
 162 static tree check_initializer PROTO((tree, tree));
 163 static void make_rtl_for_nonlocal_decl PROTO((tree, tree, const char *));
 164 static void push_cp_function_context PROTO((struct function *));
 165 static void pop_cp_function_context PROTO((struct function *));
 166 static void mark_binding_level PROTO((void *));
 167 static void mark_cp_function_context PROTO((struct function *));
 168 static void mark_saved_scope PROTO((void *));
 169 static void mark_lang_function PROTO((struct language_function *));
 170 static void mark_stmt_tree PROTO((struct stmt_tree *));
 171 static void save_function_data PROTO((tree));
 172 static void check_function_type PROTO((tree));
 173 static void destroy_local_static PROTO((tree));
 174 static void destroy_local_var PROTO((tree));
 175 static void finish_constructor_body PROTO((void));
 176 static void finish_destructor_body PROTO((void));
 177 static tree create_array_type_for_decl PROTO((tree, tree, tree));
 178 static tree get_atexit_node PROTO((void));
 179 static tree get_dso_handle_node PROTO((void));
 180 static tree start_cleanup_fn PROTO((void));
 181 static void end_cleanup_fn PROTO((void));
 182
 183 #if defined (DEBUG_CP_BINDING_LEVELS)
 184 static void indent PROTO((void));
 185 #endif
 186
 187 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 188 tree error_mark_list;
 189
 190 /* The following symbols are subsumed in the cp_global_trees array, and
 191    listed here individually for documentation purposes.
 192
 193    C++ extensions
 194         tree wchar_decl_node;
 195         tree void_zero_node;
 196
 197         tree vtable_entry_type;
 198         tree delta_type_node;
 199 #if 0
 200    Old rtti stuff.
 201         tree __baselist_desc_type_node;
 202         tree __i_desc_type_node, __m_desc_type_node;
 203         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 204 #endif
 205         tree __t_desc_type_node;
 206 #if 0
 207         tree __tp_desc_type_node;
 208 #endif
 209         tree __access_mode_type_node;
 210         tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
 211         tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
 212         tree __ptmf_desc_type_node, __ptmd_desc_type_node;
 213 #if 0
 214    Not needed yet?  May be needed one day?
 215         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 216         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 217         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 218 #endif
 219
 220         tree class_star_type_node;
 221         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 222         tree unknown_type_node;
 223
 224    Array type `vtable_entry_type[]'
 225
 226         tree vtbl_type_node;
 227         tree vtbl_ptr_type_node;
 228
 229    Nnamespace std
 230
 231         tree std_node;
 232
 233    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 234    one that the user will declare, but sufficient to be called
 235    by routines that want to abort the program.
 236
 237         tree abort_fndecl;
 238
 239    The FUNCTION_DECL for the default `::operator delete'.
 240
 241         tree global_delete_fndecl;
 242
 243    Used by RTTI
 244         tree type_info_type_node, tinfo_fn_id, tinfo_fn_type;
 245
 246 */
 247
 248 tree cp_global_trees[CPTI_MAX];
 249
 250 /* Indicates that there is a type value in some namespace, although
 251    that is not necessarily in scope at the moment.  */
 252
 253 static tree global_type_node;
 254
 255 /* Namespace std.  */
 256 int in_std;
 257
 258 /* Expect only namespace names now. */
 259 static int only_namespace_names;
 260
 261 /* If original DECL_RESULT of current function was a register,
 262    but due to being an addressable named return value, would up
 263    on the stack, this variable holds the named return value's
 264    original location.  */
 265
 266 #define original_result_rtx cp_function_chain->x_result_rtx
 267
 268 struct named_label_list
 269 {
 270   struct binding_level *binding_level;
 271   tree names_in_scope;
 272   tree label_decl;
 273   const char *filename_o_goto;
 274   int lineno_o_goto;
 275   struct named_label_list *next;
 276 };
 277
 278 /* Used only for jumps to as-yet undefined labels, since jumps to
 279    defined labels can have their validity checked by stmt.c.  */
 280
 281 #define named_label_uses cp_function_chain->x_named_label_uses
 282
 283 /* A list of objects which have constructors or destructors
 284    which reside in the global scope.  The decl is stored in
 285    the TREE_VALUE slot and the initializer is stored
 286    in the TREE_PURPOSE slot.  */
 287 tree static_aggregates;
 288
 289 /* -- end of C++ */
 290
 291 /* A node for the integer constants 2, and 3.  */
 292
 293 tree integer_two_node, integer_three_node;
 294
 295 /* Parsing a function declarator leaves here a chain of structure
 296    and enum types declared in the parmlist.  */
 297
 298 static tree last_function_parm_tags;
 299
 300 /* Similar, for last_function_parm_tags.  */
 301 tree last_function_parms;
 302 static tree current_function_parm_tags;
 303
 304 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 305    that have names.  Here so we can clear out their names' definitions
 306    at the end of the function.  The TREE_VALUE is a LABEL_DECL; the
 307    TREE_PURPOSE is the previous binding of the label.  */
 308
 309 #define named_labels cp_function_chain->x_named_labels
 310
 311 /* The FUNCTION_DECL for the function currently being compiled,
 312    or 0 if between functions.  */
 313 tree current_function_decl;
 314
 315 /* Set to 0 at beginning of a function definition, and whenever
 316    a label (case or named) is defined.  Set to value of expression
 317    returned from function when that value can be transformed into
 318    a named return value.  */
 319
 320 tree current_function_return_value;
 321
 322 /* Nonzero means give `double' the same size as `float'.  */
 323
 324 extern int flag_short_double;
 325
 326 /* Nonzero means don't recognize any builtin functions.  */
 327
 328 extern int flag_no_builtin;
 329
 330 /* Nonzero means don't recognize the non-ANSI builtin functions.
 331    -ansi sets this.  */
 332
 333 extern int flag_no_nonansi_builtin;
 334
 335 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
 336    objects.  */
 337 extern int flag_huge_objects;
 338
 339 /* Nonzero if we want to conserve space in the .o files.  We do this
 340    by putting uninitialized data and runtime initialized data into
 341    .common instead of .data at the expense of not flagging multiple
 342    definitions.  */
 343 extern int flag_conserve_space;
 344 \f
 345 /* C and C++ flags are in decl2.c.  */
 346
 347 /* Flag used when debugging spew.c */
 348
 349 extern int spew_debug;
 350
 351 /* A expression of value 0 with the same precision as a sizetype
 352    node, but signed.  */
 353 tree signed_size_zero_node;
 354
 355 /* The name of the anonymous namespace, throughout this translation
 356    unit.  */
 357 tree anonymous_namespace_name;
 358
 359 \f
 360 /* For each binding contour we allocate a binding_level structure
 361    which records the names defined in that contour.
 362    Contours include:
 363     0) the global one
 364     1) one for each function definition,
 365        where internal declarations of the parameters appear.
 366     2) one for each compound statement,
 367        to record its declarations.
 368
 369    The current meaning of a name can be found by searching the levels
 370    from the current one out to the global one.
 371
 372    Off to the side, may be the class_binding_level.  This exists only
 373    to catch class-local declarations.  It is otherwise nonexistent.
 374
 375    Also there may be binding levels that catch cleanups that must be
 376    run when exceptions occur.  Thus, to see whether a name is bound in
 377    the current scope, it is not enough to look in the
 378    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 379    instead.  */
 380
 381 /* Note that the information in the `names' component of the global contour
 382    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 383
 384 struct binding_level
 385   {
 386     /* A chain of _DECL nodes for all variables, constants, functions,
 387        and typedef types.  These are in the reverse of the order
 388        supplied.  There may be OVERLOADs on this list, too, but they
 389        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 390     tree names;
 391
 392     /* A list of structure, union and enum definitions, for looking up
 393        tag names.
 394        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 395        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 396        or ENUMERAL_TYPE node.
 397
 398        C++: the TREE_VALUE nodes can be simple types for
 399        component_bindings.  */
 400     tree tags;
 401
 402     /* A list of USING_DECL nodes. */
 403     tree usings;
 404
 405     /* A list of used namespaces. PURPOSE is the namespace,
 406        VALUE the common ancestor with this binding_level's namespace. */
 407     tree using_directives;
 408
 409     /* If this binding level is the binding level for a class, then
 410        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 411        is the name of an entity bound in the class; the TREE_VALUE is
 412        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 413        when leaving class scope, we can restore the
 414        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 415        the DECL bound by this name in the class.  */
 416     tree class_shadowed;
 417
 418     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 419        is used for all binding levels.  */
 420     tree type_shadowed;
 421
 422     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 423        label in this scope.  The TREE_PURPOSE is the previous value of
 424        the IDENTIFIER_LABEL VALUE.  */
 425     tree shadowed_labels;
 426
 427     /* For each level (except not the global one),
 428        a chain of BLOCK nodes for all the levels
 429        that were entered and exited one level down.  */
 430     tree blocks;
 431
 432     /* The BLOCK node for this level, if one has been preallocated.
 433        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 434     tree this_block;
 435
 436     /* The binding level which this one is contained in (inherits from).  */
 437     struct binding_level *level_chain;
 438
 439     /* List of decls in `names' that have incomplete
 440        structure or union types.  */
 441     tree incomplete;
 442
 443     /* List of VAR_DECLS saved from a previous for statement.
 444        These would be dead in ANSI-conforming code, but might
 445        be referenced in ARM-era code.  These are stored in a
 446        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 447     tree dead_vars_from_for;
 448
 449     /* 1 for the level that holds the parameters of a function.
 450        2 for the level that holds a class declaration.
 451        3 for levels that hold parameter declarations.  */
 452     unsigned parm_flag : 4;
 453
 454     /* 1 means make a BLOCK for this level regardless of all else.
 455        2 for temporary binding contours created by the compiler.  */
 456     unsigned keep : 3;
 457
 458     /* Nonzero if this level "doesn't exist" for tags.  */
 459     unsigned tag_transparent : 1;
 460
 461     /* Nonzero if this level can safely have additional
 462        cleanup-needing variables added to it.  */
 463     unsigned more_cleanups_ok : 1;
 464     unsigned have_cleanups : 1;
 465
 466     /* Nonzero if this level is for storing the decls for template
 467        parameters and generic decls; these decls will be discarded and
 468        replaced with a TEMPLATE_DECL.  */
 469     unsigned pseudo_global : 1;
 470
 471     /* This is set for a namespace binding level.  */
 472     unsigned namespace_p : 1;
 473
 474     /* True if this level is that of a for-statement where we need to
 475        worry about ambiguous (ARM or ANSI) scope rules.  */
 476     unsigned is_for_scope : 1;
 477
 478     /* True if this level corresponds to an EH region, as for a try block.  */
 479     unsigned eh_region : 1;
 480
 481     /* One bit left for this word.  */
 482
 483 #if defined(DEBUG_CP_BINDING_LEVELS)
 484     /* Binding depth at which this level began.  */
 485     unsigned binding_depth;
 486 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 487   };
 488
 489 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 490
 491 /* The binding level currently in effect.  */
 492
 493 #define current_binding_level                   \
 494   (cfun                                         \
 495    ? cp_function_chain->bindings                \
 496    : scope_chain->bindings)
 497
 498 /* The binding level of the current class, if any.  */
 499
 500 #define class_binding_level scope_chain->class_bindings
 501
 502 /* A chain of binding_level structures awaiting reuse.  */
 503
 504 static struct binding_level *free_binding_level;
 505
 506 /* The outermost binding level, for names of file scope.
 507    This is created when the compiler is started and exists
 508    through the entire run.  */
 509
 510 static struct binding_level *global_binding_level;
 511
 512 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 513
 514 static int keep_next_level_flag;
 515
 516 #if defined(DEBUG_CP_BINDING_LEVELS)
 517 static int binding_depth = 0;
 518 static int is_class_level = 0;
 519
 520 static void
 521 indent ()
 522 {
 523   register unsigned i;
 524
 525   for (i = 0; i < binding_depth*2; i++)
 526     putc (' ', stderr);
 527 }
 528 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 529
 530 static tree pushdecl_with_scope PROTO((tree, struct binding_level *));
 531
 532 static void
 533 push_binding_level (newlevel, tag_transparent, keep)
 534      struct binding_level *newlevel;
 535      int tag_transparent, keep;
 536 {
 537   /* Add this level to the front of the chain (stack) of levels that
 538      are active.  */
 539   bzero ((char*) newlevel, sizeof (struct binding_level));
 540   newlevel->level_chain = current_binding_level;
 541   current_binding_level = newlevel;
 542   newlevel->tag_transparent = tag_transparent;
 543   newlevel->more_cleanups_ok = 1;
 544
 545   /* We are called before expand_start_bindings, but after
 546      expand_eh_region_start for a try block; so we check this now,
 547      before the EH block is covered up.  */
 548   newlevel->eh_region = is_eh_region ();
 549
 550   newlevel->keep = keep;
 551 #if defined(DEBUG_CP_BINDING_LEVELS)
 552   newlevel->binding_depth = binding_depth;
 553   indent ();
 554   fprintf (stderr, "push %s level 0x%08x line %d\n",
 555            (is_class_level) ? "class" : "block", newlevel, lineno);
 556   is_class_level = 0;
 557   binding_depth++;
 558 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 559 }
 560
 561 /* Find the innermost enclosing class scope, and reset
 562    CLASS_BINDING_LEVEL appropriately.  */
 563
 564 static void
 565 find_class_binding_level ()
 566 {
 567   struct binding_level *level = current_binding_level;
 568
 569   while (level && level->parm_flag != 2)
 570     level = level->level_chain;
 571   if (level && level->parm_flag == 2)
 572     class_binding_level = level;
 573   else
 574     class_binding_level = 0;
 575 }
 576
 577 static void
 578 pop_binding_level ()
 579 {
 580   if (global_binding_level)
 581     {
 582       /* Cannot pop a level, if there are none left to pop.  */
 583       if (current_binding_level == global_binding_level)
 584         my_friendly_abort (123);
 585     }
 586   /* Pop the current level, and free the structure for reuse.  */
 587 #if defined(DEBUG_CP_BINDING_LEVELS)
 588   binding_depth--;
 589   indent ();
 590   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 591           (is_class_level) ? "class" : "block",
 592           current_binding_level, lineno);
 593   if (is_class_level != (current_binding_level == class_binding_level))
 594     {
 595       indent ();
 596       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 597     }
 598   is_class_level = 0;
 599 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 600   {
 601     register struct binding_level *level = current_binding_level;
 602     current_binding_level = current_binding_level->level_chain;
 603     level->level_chain = free_binding_level;
 604 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 605     if (level->binding_depth != binding_depth)
 606       abort ();
 607 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 608     free_binding_level = level;
 609     find_class_binding_level ();
 610   }
 611 }
 612
 613 static void
 614 suspend_binding_level ()
 615 {
 616   if (class_binding_level)
 617     current_binding_level = class_binding_level;
 618
 619   if (global_binding_level)
 620     {
 621       /* Cannot suspend a level, if there are none left to suspend.  */
 622       if (current_binding_level == global_binding_level)
 623         my_friendly_abort (123);
 624     }
 625   /* Suspend the current level.  */
 626 #if defined(DEBUG_CP_BINDING_LEVELS)
 627   binding_depth--;
 628   indent ();
 629   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 630           (is_class_level) ? "class" : "block",
 631           current_binding_level, lineno);
 632   if (is_class_level != (current_binding_level == class_binding_level))
 633     {
 634       indent ();
 635       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 636     }
 637   is_class_level = 0;
 638 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 639   current_binding_level = current_binding_level->level_chain;
 640   find_class_binding_level ();
 641 }
 642
 643 static void
 644 resume_binding_level (b)
 645      struct binding_level *b;
 646 {
 647   /* Resuming binding levels is meant only for namespaces,
 648      and those cannot nest into classes. */
 649   my_friendly_assert(!class_binding_level, 386);
 650   /* Also, resuming a non-directly nested namespace is a no-no.  */
 651   my_friendly_assert(b->level_chain == current_binding_level, 386);
 652   current_binding_level = b;
 653 #if defined(DEBUG_CP_BINDING_LEVELS)
 654   b->binding_depth = binding_depth;
 655   indent ();
 656   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 657            (is_class_level) ? "class" : "block", b, lineno);
 658   is_class_level = 0;
 659   binding_depth++;
 660 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 661 }
 662 \f
 663 /* Create a new `struct binding_level'.  */
 664
 665 static
 666 struct binding_level *
 667 make_binding_level ()
 668 {
 669   /* NOSTRICT */
 670   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 671 }
 672
 673 /* Nonzero if we are currently in the global binding level.  */
 674
 675 int
 676 global_bindings_p ()
 677 {
 678   return current_binding_level == global_binding_level;
 679 }
 680
 681 /* Return the innermost binding level that is not for a class scope.  */
 682
 683 static struct binding_level *
 684 innermost_nonclass_level ()
 685 {
 686   struct binding_level *b;
 687
 688   b = current_binding_level;
 689   while (b->parm_flag == 2)
 690     b = b->level_chain;
 691
 692   return b;
 693 }
 694
 695 /* Nonzero if we are currently in a toplevel binding level.  This
 696    means either the global binding level or a namespace in a toplevel
 697    binding level.  Since there are no non-toplevel namespace levels,
 698    this really means any namespace or pseudo-global level.  We also
 699    include a class whose context is toplevel.  */
 700
 701 int
 702 toplevel_bindings_p ()
 703 {
 704   struct binding_level *b = innermost_nonclass_level ();
 705
 706   return b->namespace_p || b->pseudo_global;
 707 }
 708
 709 /* Nonzero if this is a namespace scope, or if we are defining a class
 710    which is itself at namespace scope, or whose enclosing class is
 711    such a class, etc.  */
 712
 713 int
 714 namespace_bindings_p ()
 715 {
 716   struct binding_level *b = innermost_nonclass_level ();
 717
 718   return b->namespace_p;
 719 }
 720
 721 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 722    unconditionally.  Otherwise, use the normal logic to decide whether
 723    or not to create a BLOCK.  */
 724
 725 void
 726 keep_next_level (keep)
 727      int keep;
 728 {
 729   keep_next_level_flag = keep;
 730 }
 731
 732 /* Nonzero if the current level needs to have a BLOCK made.  */
 733
 734 int
 735 kept_level_p ()
 736 {
 737   return (current_binding_level->blocks != NULL_TREE
 738           || current_binding_level->keep
 739           || current_binding_level->names != NULL_TREE
 740           || (current_binding_level->tags != NULL_TREE
 741               && !current_binding_level->tag_transparent));
 742 }
 743
 744 void
 745 declare_pseudo_global_level ()
 746 {
 747   current_binding_level->pseudo_global = 1;
 748 }
 749
 750 static void
 751 declare_namespace_level ()
 752 {
 753   current_binding_level->namespace_p = 1;
 754 }
 755
 756 int
 757 pseudo_global_level_p ()
 758 {
 759   return current_binding_level->pseudo_global;
 760 }
 761
 762 void
 763 set_class_shadows (shadows)
 764      tree shadows;
 765 {
 766   class_binding_level->class_shadowed = shadows;
 767 }
 768
 769 /* Enter a new binding level.
 770    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 771    not for that of tags.  */
 772
 773 void
 774 pushlevel (tag_transparent)
 775      int tag_transparent;
 776 {
 777   struct binding_level *newlevel;
 778
 779   if (cfun && !doing_semantic_analysis_p ())
 780     return;
 781
 782   /* Reuse or create a struct for this binding level.  */
 783 #if defined(DEBUG_CP_BINDING_LEVELS)
 784   if (0)
 785 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 786   if (free_binding_level)
 787 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 788     {
 789       newlevel = free_binding_level;
 790       free_binding_level = free_binding_level->level_chain;
 791     }
 792   else
 793     newlevel = make_binding_level ();
 794
 795   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 796   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 797   keep_next_level_flag = 0;
 798 }
 799
 800 void
 801 note_level_for_for ()
 802 {
 803   current_binding_level->is_for_scope = 1;
 804 }
 805
 806 /* For a binding between a name and an entity at a block scope,
 807    this is the `struct binding_level' for the block.  */
 808 #define BINDING_LEVEL(NODE) \
 809    (((struct tree_binding*)NODE)->scope.level)
 810
 811 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 812    level at which this declaration is being bound.  */
 813
 814 static void
 815 push_binding (id, decl, level)
 816      tree id;
 817      tree decl;
 818      struct binding_level* level;
 819 {
 820   tree binding;
 821
 822   binding = make_node (CPLUS_BINDING);
 823
 824   /* Now, fill in the binding information.  */
 825   BINDING_VALUE (binding) = decl;
 826   BINDING_TYPE (binding) = NULL_TREE;
 827   BINDING_LEVEL (binding) = level;
 828   INHERITED_VALUE_BINDING_P (binding) = 0;
 829   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 830   BINDING_HAS_LEVEL_P (binding) = 1;
 831
 832   /* And put it on the front of the list of bindings for ID.  */
 833   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 834   IDENTIFIER_BINDING (id) = binding;
 835 }
 836
 837 /* ID is already bound in the current scope.  But, DECL is an
 838    additional binding for ID in the same scope.  This is the `struct
 839    stat' hack whereby a non-typedef class-name or enum-name can be
 840    bound at the same level as some other kind of entity.  It's the
 841    responsibility of the caller to check that inserting this name is
 842    legal here.  Returns nonzero if the new binding was successful.  */
 843 static int
 844 add_binding (id, decl)
 845      tree id;
 846      tree decl;
 847 {
 848   tree binding = IDENTIFIER_BINDING (id);
 849   int ok = 1;
 850
 851   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 852     /* The new name is the type name.  */
 853     BINDING_TYPE (binding) = decl;
 854   else if (!BINDING_VALUE (binding))
 855     /* This situation arises when push_class_level_binding moves an
 856        inherited type-binding out of the way to make room for a new
 857        value binding.  */
 858     BINDING_VALUE (binding) = decl;
 859   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 860            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 861     {
 862       /* The old binding was a type name.  It was placed in
 863          BINDING_VALUE because it was thought, at the point it was
 864          declared, to be the only entity with such a name.  Move the
 865          type name into the type slot; it is now hidden by the new
 866          binding.  */
 867       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 868       BINDING_VALUE (binding) = decl;
 869       INHERITED_VALUE_BINDING_P (binding) = 0;
 870     }
 871   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 872            && TREE_CODE (decl) == TYPE_DECL
 873            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 874            && same_type_p (TREE_TYPE (decl),
 875                            TREE_TYPE (BINDING_VALUE (binding))))
 876     /* We have two typedef-names, both naming the same type to have
 877        the same name.  This is OK because of:
 878
 879          [dcl.typedef]
 880
 881          In a given scope, a typedef specifier can be used to redefine
 882          the name of any type declared in that scope to refer to the
 883          type to which it already refers.  */
 884     ok = 0;
 885   else
 886     {
 887       cp_error ("declaration of `%#D'", decl);
 888       cp_error_at ("conflicts with previous declaration `%#D'",
 889                    BINDING_VALUE (binding));
 890       ok = 0;
 891     }
 892
 893   return ok;
 894 }
 895
 896 /* Add DECL to the list of things declared in B.  */
 897
 898 static void
 899 add_decl_to_level (decl, b)
 900      tree decl;
 901      struct binding_level *b;
 902 {
 903   /* We build up the list in reverse order, and reverse it later if
 904      necessary.  */
 905   TREE_CHAIN (decl) = b->names;
 906   b->names = decl;
 907 }
 908
 909 /* Bind DECL to ID in the current_binding_level, assumed to be a local
 910    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
 911    doesn't really belong to this binding level, that it got here
 912    through a using-declaration.  */
 913
 914 void
 915 push_local_binding (id, decl, flags)
 916      tree id;
 917      tree decl;
 918      int flags;
 919 {
 920   struct binding_level *b;
 921
 922   /* Skip over any local classes.  This makes sense if we call
 923      push_local_binding with a friend decl of a local class.  */
 924   b = current_binding_level;
 925   while (b->parm_flag == 2)
 926     b = b->level_chain;
 927
 928   if (lookup_name_current_level (id))
 929     {
 930       /* Supplement the existing binding.  */
 931       if (!add_binding (id, decl))
 932         /* It didn't work.  Something else must be bound at this
 933            level.  Do not add DECL to the list of things to pop
 934            later.  */
 935         return;
 936     }
 937   else
 938     /* Create a new binding.  */
 939     push_binding (id, decl, b);
 940
 941   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
 942     /* We must put the OVERLOAD into a TREE_LIST since the
 943        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
 944        decls that got here through a using-declaration.  */
 945     decl = build_tree_list (NULL_TREE, decl);
 946
 947   /* And put DECL on the list of things declared by the current
 948      binding level.  */
 949   add_decl_to_level (decl, b);
 950 }
 951
 952 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
 953    binding was successful.  */
 954
 955 int
 956 push_class_binding (id, decl)
 957      tree id;
 958      tree decl;
 959 {
 960   int result = 1;
 961   tree binding = IDENTIFIER_BINDING (id);
 962   tree context;
 963
 964   /* Note that we declared this value so that we can issue an error if
 965      this an illegal redeclaration of a name already used for some
 966      other purpose.  */
 967   note_name_declared_in_class (id, decl);
 968
 969   if (binding && BINDING_LEVEL (binding) == class_binding_level)
 970     /* Supplement the existing binding.  */
 971     result = add_binding (id, decl);
 972   else
 973     /* Create a new binding.  */
 974     push_binding (id, decl, class_binding_level);
 975
 976   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
 977      class-level declaration.  Note that we do not use DECL here
 978      because of the possibility of the `struct stat' hack; if DECL is
 979      a class-name or enum-name we might prefer a field-name, or some
 980      such.  */
 981   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
 982
 983   /* If this is a binding from a base class, mark it as such.  */
 984   binding = IDENTIFIER_BINDING (id);
 985   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
 986     {
 987       /* Any implicit typename must be from a base-class.  The
 988          context for an implicit typename declaration is always
 989          the derived class in which the lookup was done, so the checks
 990          based on the context of DECL below will not trigger.  */
 991       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
 992         INHERITED_VALUE_BINDING_P (binding) = 1;
 993       else
 994         {
 995           if (TREE_CODE (decl) == OVERLOAD)
 996             context = DECL_REAL_CONTEXT (OVL_CURRENT (decl));
 997           else
 998             {
 999               my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd',
1000                                   0);
1001               context = DECL_REAL_CONTEXT (decl);
1002             }
1003
1004           if (is_properly_derived_from (current_class_type, context))
1005             INHERITED_VALUE_BINDING_P (binding) = 1;
1006           else
1007             INHERITED_VALUE_BINDING_P (binding) = 0;
1008         }
1009     }
1010   else if (BINDING_VALUE (binding) == decl)
1011     /* We only encounter a TREE_LIST when push_class_decls detects an
1012        ambiguity.  Such an ambiguity can be overridden by a definition
1013        in this class.  */
1014     INHERITED_VALUE_BINDING_P (binding) = 1;
1015
1016   return result;
1017 }
1018
1019 /* Remove the binding for DECL which should be the innermost binding
1020    for ID.  */
1021
1022 static void
1023 pop_binding (id, decl)
1024      tree id;
1025      tree decl;
1026 {
1027   tree binding;
1028
1029   if (id == NULL_TREE)
1030     /* It's easiest to write the loops that call this function without
1031        checking whether or not the entities involved have names.  We
1032        get here for such an entity.  */
1033     return;
1034
1035   /* Get the innermost binding for ID.  */
1036   binding = IDENTIFIER_BINDING (id);
1037
1038   /* The name should be bound.  */
1039   my_friendly_assert (binding != NULL_TREE, 0);
1040
1041   /* The DECL will be either the ordinary binding or the type
1042      binding for this identifier.  Remove that binding.  */
1043   if (BINDING_VALUE (binding) == decl)
1044     BINDING_VALUE (binding) = NULL_TREE;
1045   else if (BINDING_TYPE (binding) == decl)
1046     BINDING_TYPE (binding) = NULL_TREE;
1047   else
1048     my_friendly_abort (0);
1049
1050   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1051     /* We're completely done with the innermost binding for this
1052        identifier.  Unhook it from the list of bindings.  */
1053     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1054 }
1055
1056 /* When a label goes out of scope, check to see if that label was used
1057    in a valid manner, and issue any appropriate warnings or errors.  */
1058
1059 static void
1060 pop_label (link)
1061      tree link;
1062 {
1063   tree label = TREE_VALUE (link);
1064
1065   if (!processing_template_decl && doing_semantic_analysis_p ())
1066     {
1067       if (DECL_INITIAL (label) == NULL_TREE)
1068         {
1069           cp_error_at ("label `%D' used but not defined", label);
1070           /* Avoid crashing later.  */
1071           define_label (input_filename, 1, DECL_NAME (label));
1072         }
1073       else if (warn_unused && !TREE_USED (label))
1074         cp_warning_at ("label `%D' defined but not used", label);
1075     }
1076
1077   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), TREE_PURPOSE (link));
1078 }
1079
1080 /* At the end of a function, all labels declared within the fucntion
1081    go out of scope.  BLOCK is the top-level block for the
1082    function.  */
1083
1084 static void
1085 pop_labels (block)
1086      tree block;
1087 {
1088   tree link;
1089
1090   /* Clear out the definitions of all label names, since their scopes
1091      end here.  */
1092   for (link = named_labels; link; link = TREE_CHAIN (link))
1093     {
1094       pop_label (link);
1095       /* Put the labels into the "variables" of the top-level block,
1096          so debugger can see them.  */
1097       TREE_CHAIN (TREE_VALUE (link)) = BLOCK_VARS (block);
1098       BLOCK_VARS (block) = TREE_VALUE (link);
1099     }
1100
1101   named_labels = NULL_TREE;
1102 }
1103
1104 /* Exit a binding level.
1105    Pop the level off, and restore the state of the identifier-decl mappings
1106    that were in effect when this level was entered.
1107
1108    If KEEP == 1, this level had explicit declarations, so
1109    and create a "block" (a BLOCK node) for the level
1110    to record its declarations and subblocks for symbol table output.
1111
1112    If FUNCTIONBODY is nonzero, this level is the body of a function,
1113    so create a block as if KEEP were set and also clear out all
1114    label names.
1115
1116    If REVERSE is nonzero, reverse the order of decls before putting
1117    them into the BLOCK.  */
1118
1119 tree
1120 poplevel (keep, reverse, functionbody)
1121      int keep;
1122      int reverse;
1123      int functionbody;
1124 {
1125   register tree link;
1126   /* The chain of decls was accumulated in reverse order.
1127      Put it into forward order, just for cleanliness.  */
1128   tree decls;
1129   int tmp = functionbody;
1130   int real_functionbody;
1131   tree tags;
1132   tree subblocks;
1133   tree block = NULL_TREE;
1134   tree decl;
1135   int block_previously_created;
1136   int leaving_for_scope;
1137
1138   if (cfun && !doing_semantic_analysis_p ())
1139     return NULL_TREE;
1140
1141   my_friendly_assert (current_binding_level->parm_flag != 2,
1142                       19990916);
1143
1144   real_functionbody = (current_binding_level->keep == 2
1145                        ? ((functionbody = 0), tmp) : functionbody);
1146   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1147   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1148
1149   my_friendly_assert (!current_binding_level->class_shadowed,
1150                       19990414);
1151
1152   /* We used to use KEEP == 2 to indicate that the new block should go
1153      at the beginning of the list of blocks at this binding level,
1154      rather than the end.  This hack is no longer used.  */
1155   my_friendly_assert (keep == 0 || keep == 1, 0);
1156
1157   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1158                       (HOST_WIDE_INT) current_binding_level->level_chain,
1159                       current_binding_level->parm_flag,
1160                       current_binding_level->keep);
1161
1162   if (current_binding_level->keep == 1)
1163     keep = 1;
1164
1165   /* Get the decls in the order they were written.
1166      Usually current_binding_level->names is in reverse order.
1167      But parameter decls were previously put in forward order.  */
1168
1169   if (reverse)
1170     current_binding_level->names
1171       = decls = nreverse (current_binding_level->names);
1172   else
1173     decls = current_binding_level->names;
1174
1175   /* Output any nested inline functions within this block
1176      if they weren't already output.  */
1177   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1178     if (TREE_CODE (decl) == FUNCTION_DECL
1179         && ! TREE_ASM_WRITTEN (decl)
1180         && DECL_INITIAL (decl) != NULL_TREE
1181         && TREE_ADDRESSABLE (decl)
1182         && decl_function_context (decl) == current_function_decl)
1183       {
1184         /* If this decl was copied from a file-scope decl
1185            on account of a block-scope extern decl,
1186            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1187         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1188           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1189         else
1190           {
1191             push_function_context ();
1192             output_inline_function (decl);
1193             pop_function_context ();
1194           }
1195       }
1196
1197   /* When not in function-at-a-time mode, expand_end_bindings will
1198      warn about unused variables.  But, in function-at-a-time mode
1199      expand_end_bindings is not passed the list of variables in the
1200      current scope, and therefore no warning is emitted.  So, we
1201      explicitly warn here.  */
1202   if (!processing_template_decl)
1203     warn_about_unused_variables (getdecls ());
1204
1205   /* If there were any declarations or structure tags in that level,
1206      or if this level is a function body,
1207      create a BLOCK to record them for the life of this function.  */
1208   block = NULL_TREE;
1209   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1210   if (block_previously_created)
1211     block = current_binding_level->this_block;
1212   else if (keep == 1 || functionbody)
1213     block = make_node (BLOCK);
1214   if (block != NULL_TREE)
1215     {
1216       if (block_previously_created)
1217         {
1218           if (decls || tags || subblocks)
1219             {
1220               if (BLOCK_VARS (block))
1221                 warning ("internal compiler error: debugging info corrupted");
1222
1223               BLOCK_VARS (block) = decls;
1224
1225               /* We can have previous subblocks and new subblocks when
1226                  doing fixup_gotos with complex cleanups.  We chain the new
1227                  subblocks onto the end of any pre-existing subblocks.  */
1228               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1229                                                  subblocks);
1230             }
1231         }
1232       else
1233         {
1234           BLOCK_VARS (block) = decls;
1235           BLOCK_SUBBLOCKS (block) = subblocks;
1236         }
1237     }
1238
1239   /* In each subblock, record that this is its superior.  */
1240   if (keep >= 0)
1241     for (link = subblocks; link; link = TREE_CHAIN (link))
1242       BLOCK_SUPERCONTEXT (link) = block;
1243
1244   /* We still support the old for-scope rules, whereby the variables
1245      in a for-init statement were in scope after the for-statement
1246      ended.  We only use the new rules in flag_new_for_scope is
1247      nonzero.  */
1248   leaving_for_scope
1249     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1250
1251   /* Remove declarations for all the DECLs in this level.  */
1252   for (link = decls; link; link = TREE_CHAIN (link))
1253     {
1254       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1255         {
1256           tree outer_binding
1257             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1258           tree ns_binding;
1259
1260           if (!outer_binding)
1261             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1262           else
1263             ns_binding = NULL_TREE;
1264
1265           if (outer_binding
1266               && (BINDING_LEVEL (outer_binding)
1267                   == current_binding_level->level_chain))
1268             /* We have something like:
1269
1270                  int i;
1271                  for (int i; ;);
1272
1273                and we are leaving the `for' scope.  There's no reason to
1274                keep the binding of the inner `i' in this case.  */
1275             pop_binding (DECL_NAME (link), link);
1276           else if ((outer_binding
1277                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1278                         == TYPE_DECL))
1279                    || (ns_binding
1280                        && TREE_CODE (ns_binding) == TYPE_DECL))
1281             /* Here, we have something like:
1282
1283                  typedef int I;
1284
1285                  void f () {
1286                    for (int I; ;);
1287                  }
1288
1289                We must pop the for-scope binding so we know what's a
1290                type and what isn't.  */
1291             pop_binding (DECL_NAME (link), link);
1292           else
1293             {
1294               /* Mark this VAR_DECL as dead so that we can tell we left it
1295                  there only for backward compatibility.  */
1296               DECL_DEAD_FOR_LOCAL (link) = 1;
1297
1298               /* Keep track of what should of have happenned when we
1299                  popped the binding.  */
1300               if (outer_binding && BINDING_VALUE (outer_binding))
1301                 DECL_SHADOWED_FOR_VAR (link)
1302                   = BINDING_VALUE (outer_binding);
1303
1304               /* Add it to the list of dead variables in the next
1305                  outermost binding to that we can remove these when we
1306                  leave that binding.  */
1307               current_binding_level->level_chain->dead_vars_from_for
1308                 = tree_cons (NULL_TREE, link,
1309                              current_binding_level->level_chain->
1310                              dead_vars_from_for);
1311
1312               /* Although we don't pop the CPLUS_BINDING, we do clear
1313                  its BINDING_LEVEL since the level is going away now.  */
1314               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1315                 = 0;
1316             }
1317         }
1318       else
1319         {
1320           /* Remove the binding.  */
1321           decl = link;
1322           if (TREE_CODE (decl) == TREE_LIST)
1323             decl = TREE_VALUE (decl);
1324           if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
1325             pop_binding (DECL_NAME (decl), decl);
1326           else if (TREE_CODE (decl) == OVERLOAD)
1327             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1328           else
1329             my_friendly_abort (0);
1330         }
1331     }
1332
1333   /* Remove declarations for any `for' variables from inner scopes
1334      that we kept around.  */
1335   for (link = current_binding_level->dead_vars_from_for;
1336        link; link = TREE_CHAIN (link))
1337     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1338
1339   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1340   for (link = current_binding_level->type_shadowed;
1341        link; link = TREE_CHAIN (link))
1342     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1343
1344   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1345   for (link = current_binding_level->shadowed_labels;
1346        link;
1347        link = TREE_CHAIN (link))
1348     pop_label (link);
1349
1350   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1351      list if a `using' declaration put them there.  The debugging
1352      back-ends won't understand OVERLOAD, so we remove them here.
1353      Because the BLOCK_VARS are (temporarily) shared with
1354      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1355      popped all the bindings.  */
1356   if (block)
1357     {
1358       tree* d;
1359
1360       for (d = &BLOCK_VARS (block); *d; )
1361         {
1362           if (TREE_CODE (*d) == TREE_LIST)
1363             *d = TREE_CHAIN (*d);
1364           else
1365             d = &TREE_CHAIN (*d);
1366         }
1367     }
1368
1369   /* If the level being exited is the top level of a function,
1370      check over all the labels.  */
1371   if (functionbody)
1372     {
1373       /* Since this is the top level block of a function, the vars are
1374          the function's parameters.  Don't leave them in the BLOCK
1375          because they are found in the FUNCTION_DECL instead.  */
1376       BLOCK_VARS (block) = 0;
1377       pop_labels (block);
1378     }
1379
1380   /* Any uses of undefined labels now operate under constraints
1381      of next binding contour.  */
1382   if (cfun)
1383     {
1384       struct binding_level *level_chain;
1385       level_chain = current_binding_level->level_chain;
1386       if (level_chain)
1387         {
1388           struct named_label_list *labels;
1389           for (labels = named_label_uses; labels; labels = labels->next)
1390             if (labels->binding_level == current_binding_level)
1391               {
1392                 labels->binding_level = level_chain;
1393                 labels->names_in_scope = level_chain->names;
1394               }
1395         }
1396     }
1397
1398   tmp = current_binding_level->keep;
1399
1400   pop_binding_level ();
1401   if (functionbody)
1402     DECL_INITIAL (current_function_decl) = block;
1403   else if (block)
1404     {
1405       if (!block_previously_created)
1406         current_binding_level->blocks
1407           = chainon (current_binding_level->blocks, block);
1408     }
1409   /* If we did not make a block for the level just exited,
1410      any blocks made for inner levels
1411      (since they cannot be recorded as subblocks in that level)
1412      must be carried forward so they will later become subblocks
1413      of something else.  */
1414   else if (subblocks)
1415     current_binding_level->blocks
1416       = chainon (current_binding_level->blocks, subblocks);
1417
1418   /* Each and every BLOCK node created here in `poplevel' is important
1419      (e.g. for proper debugging information) so if we created one
1420      earlier, mark it as "used".  */
1421   if (block)
1422     TREE_USED (block) = 1;
1423
1424   /* Take care of compiler's internal binding structures.  */
1425   if (tmp == 2)
1426     {
1427       tree scope_stmts;
1428
1429       scope_stmts
1430         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1431       if (block)
1432         {
1433           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1434           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1435         }
1436
1437       block = poplevel (keep, reverse, functionbody);
1438     }
1439
1440   return block;
1441 }
1442
1443 /* Delete the node BLOCK from the current binding level.
1444    This is used for the block inside a stmt expr ({...})
1445    so that the block can be reinserted where appropriate.  */
1446
1447 void
1448 delete_block (block)
1449      tree block;
1450 {
1451   tree t;
1452   if (current_binding_level->blocks == block)
1453     current_binding_level->blocks = TREE_CHAIN (block);
1454   for (t = current_binding_level->blocks; t;)
1455     {
1456       if (TREE_CHAIN (t) == block)
1457         TREE_CHAIN (t) = TREE_CHAIN (block);
1458       else
1459         t = TREE_CHAIN (t);
1460     }
1461   TREE_CHAIN (block) = NULL_TREE;
1462   /* Clear TREE_USED which is always set by poplevel.
1463      The flag is set again if insert_block is called.  */
1464   TREE_USED (block) = 0;
1465 }
1466
1467 /* Insert BLOCK at the end of the list of subblocks of the
1468    current binding level.  This is used when a BIND_EXPR is expanded,
1469    to handle the BLOCK node inside the BIND_EXPR.  */
1470
1471 void
1472 insert_block (block)
1473      tree block;
1474 {
1475   TREE_USED (block) = 1;
1476   current_binding_level->blocks
1477     = chainon (current_binding_level->blocks, block);
1478 }
1479
1480 /* Set the BLOCK node for the innermost scope
1481    (the one we are currently in).  */
1482
1483 void
1484 set_block (block)
1485     register tree block;
1486 {
1487   current_binding_level->this_block = block;
1488 }
1489
1490 /* Do a pushlevel for class declarations.  */
1491
1492 void
1493 pushlevel_class ()
1494 {
1495   register struct binding_level *newlevel;
1496
1497   /* Reuse or create a struct for this binding level.  */
1498 #if defined(DEBUG_CP_BINDING_LEVELS)
1499   if (0)
1500 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1501   if (free_binding_level)
1502 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1503     {
1504       newlevel = free_binding_level;
1505       free_binding_level = free_binding_level->level_chain;
1506     }
1507   else
1508     newlevel = make_binding_level ();
1509
1510 #if defined(DEBUG_CP_BINDING_LEVELS)
1511   is_class_level = 1;
1512 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1513
1514   push_binding_level (newlevel, 0, 0);
1515
1516   class_binding_level = current_binding_level;
1517   class_binding_level->parm_flag = 2;
1518 }
1519
1520 /* ...and a poplevel for class declarations.  */
1521
1522 void
1523 poplevel_class ()
1524 {
1525   register struct binding_level *level = class_binding_level;
1526   tree shadowed;
1527
1528   my_friendly_assert (level != 0, 354);
1529
1530   /* If we're leaving a toplevel class, don't bother to do the setting
1531      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1532      shouldn't even be used when current_class_type isn't set, and second,
1533      if we don't touch it here, we're able to use the cache effect if the
1534      next time we're entering a class scope, it is the same class.  */
1535   if (current_class_depth != 1)
1536     {
1537       struct binding_level* b;
1538
1539       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1540       for (shadowed = level->class_shadowed;
1541            shadowed;
1542            shadowed = TREE_CHAIN (shadowed))
1543         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1544
1545       /* Find the next enclosing class, and recreate
1546          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1547       b = level->level_chain;
1548       while (b && b->parm_flag != 2)
1549         b = b->level_chain;
1550
1551       if (b)
1552         for (shadowed = b->class_shadowed;
1553              shadowed;
1554              shadowed = TREE_CHAIN (shadowed))
1555           {
1556             tree t;
1557
1558             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1559             while (t && BINDING_LEVEL (t) != b)
1560               t = TREE_CHAIN (t);
1561
1562             if (t)
1563               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1564                 = BINDING_VALUE (t);
1565           }
1566     }
1567   else
1568     /* Remember to save what IDENTIFIER's were bound in this scope so we
1569        can recover from cache misses.  */
1570     {
1571       previous_class_type = current_class_type;
1572       previous_class_values = class_binding_level->class_shadowed;
1573     }
1574   for (shadowed = level->type_shadowed;
1575        shadowed;
1576        shadowed = TREE_CHAIN (shadowed))
1577     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1578
1579   /* Remove the bindings for all of the class-level declarations.  */
1580   for (shadowed = level->class_shadowed;
1581        shadowed;
1582        shadowed = TREE_CHAIN (shadowed))
1583     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1584
1585   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1586                       (HOST_WIDE_INT) class_binding_level->level_chain,
1587                       class_binding_level->parm_flag,
1588                       class_binding_level->keep);
1589
1590   /* Now, pop out of the binding level which we created up in the
1591      `pushlevel_class' routine.  */
1592 #if defined(DEBUG_CP_BINDING_LEVELS)
1593   is_class_level = 1;
1594 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1595
1596   pop_binding_level ();
1597 }
1598
1599 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1600    for any names in enclosing classes.  */
1601
1602 void
1603 clear_identifier_class_values ()
1604 {
1605   tree t;
1606
1607   if (!class_binding_level)
1608     return;
1609
1610   for (t = class_binding_level->class_shadowed;
1611        t;
1612        t = TREE_CHAIN (t))
1613     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1614 }
1615
1616 /* Returns non-zero if T is a virtual function table.  */
1617
1618 int
1619 vtable_decl_p (t, data)
1620      tree t;
1621      void *data ATTRIBUTE_UNUSED;
1622 {
1623   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1624 }
1625
1626 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1627    functions.  */
1628
1629 int
1630 vtype_decl_p (t, data)
1631      tree t;
1632      void *data ATTRIBUTE_UNUSED;
1633 {
1634   return (TREE_CODE (t) == TYPE_DECL
1635           && TREE_TYPE (t) != error_mark_node
1636           && TYPE_LANG_SPECIFIC (TREE_TYPE (t))
1637           && CLASSTYPE_VSIZE (TREE_TYPE (t)));
1638 }
1639
1640 /* Return the declarations that are members of the namespace NS.  */
1641
1642 tree
1643 cp_namespace_decls (ns)
1644      tree ns;
1645 {
1646   return NAMESPACE_LEVEL (ns)->names;
1647 }
1648
1649 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1650    itself, calling F for each.  The DATA is passed to F as well.  */
1651
1652 static int
1653 walk_namespaces_r (namespace, f, data)
1654      tree namespace;
1655      walk_namespaces_fn f;
1656      void *data;
1657 {
1658   tree current;
1659   int result = 0;
1660
1661   result |= (*f) (namespace, data);
1662
1663   for (current = cp_namespace_decls (namespace);
1664        current;
1665        current = TREE_CHAIN (current))
1666     {
1667       if (TREE_CODE (current) != NAMESPACE_DECL
1668           || DECL_NAMESPACE_ALIAS (current))
1669         continue;
1670       if (!DECL_LANG_SPECIFIC (current))
1671         {
1672           /* Hmm. std. */
1673           my_friendly_assert (current == std_node, 393);
1674           continue;
1675         }
1676
1677       /* We found a namespace.  */
1678       result |= walk_namespaces_r (current, f, data);
1679     }
1680
1681   return result;
1682 }
1683
1684 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1685    F as well.  */
1686
1687 int
1688 walk_namespaces (f, data)
1689      walk_namespaces_fn f;
1690      void *data;
1691 {
1692   return walk_namespaces_r (global_namespace, f, data);
1693 }
1694
1695 struct walk_globals_data {
1696   walk_globals_pred p;
1697   walk_globals_fn f;
1698   void *data;
1699 };
1700
1701 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1702    for which P returns non-zero, call F with its address.  If any call
1703    to F returns a non-zero value, return a non-zero value.  */
1704
1705 static int
1706 walk_globals_r (namespace, data)
1707      tree namespace;
1708      void *data;
1709 {
1710   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1711   walk_globals_pred p = wgd->p;
1712   walk_globals_fn f = wgd->f;
1713   void *d = wgd->data;
1714   tree *t;
1715   int result = 0;
1716
1717   t = &NAMESPACE_LEVEL (namespace)->names;
1718
1719   while (*t)
1720     {
1721       tree glbl = *t;
1722
1723       if ((*p) (glbl, d))
1724         result |= (*f) (t, d);
1725
1726       /* If F changed *T, then *T still points at the next item to
1727          examine.  */
1728       if (*t == glbl)
1729         t = &TREE_CHAIN (*t);
1730     }
1731
1732   return result;
1733 }
1734
1735 /* Walk the global declarations.  Whenever one is found for which P
1736    returns non-zero, call F with its address.  If any call to F
1737    returns a non-zero value, return a non-zero value.  */
1738
1739 int
1740 walk_globals (p, f, data)
1741      walk_globals_pred p;
1742      walk_globals_fn f;
1743      void *data;
1744 {
1745   struct walk_globals_data wgd;
1746   wgd.p = p;
1747   wgd.f = f;
1748   wgd.data = data;
1749
1750   return walk_namespaces (walk_globals_r, &wgd);
1751 }
1752
1753 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1754    DATA is non-NULL, this is the last time we will call
1755    wrapup_global_declarations for this NAMESPACE.  */
1756
1757 int
1758 wrapup_globals_for_namespace (namespace, data)
1759      tree namespace;
1760      void *data;
1761 {
1762   tree globals = cp_namespace_decls (namespace);
1763   int len = list_length (globals);
1764   tree *vec = (tree *) alloca (sizeof (tree) * len);
1765   int i;
1766   int result;
1767   tree decl;
1768   int last_time = (data != 0);
1769
1770   if (last_time && namespace == global_namespace)
1771     /* Let compile_file handle the global namespace.  */
1772     return 0;
1773
1774   /* Process the decls in reverse order--earliest first.
1775      Put them into VEC from back to front, then take out from front.  */
1776
1777   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1778     vec[len - i - 1] = decl;
1779
1780   if (last_time)
1781     {
1782       check_global_declarations (vec, len);
1783       return 0;
1784     }
1785
1786   /* Temporarily mark vtables as external.  That prevents
1787      wrapup_global_declarations from writing them out; we must process
1788      them ourselves in finish_vtable_vardecl.  */
1789   for (i = 0; i < len; ++i)
1790     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1791       {
1792         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1793         DECL_EXTERNAL (vec[i]) = 1;
1794       }
1795
1796   /* Write out any globals that need to be output.  */
1797   result = wrapup_global_declarations (vec, len);
1798
1799   /* Undo the hack to DECL_EXTERNAL above.  */
1800   for (i = 0; i < len; ++i)
1801     if (vtable_decl_p (vec[i], /*data=*/0)
1802         && DECL_NOT_REALLY_EXTERN (vec[i]))
1803       {
1804         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1805         DECL_EXTERNAL (vec[i]) = 0;
1806       }
1807
1808   return result;
1809 }
1810
1811 \f
1812 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1813
1814 static void
1815 mark_binding_level (arg)
1816      void *arg;
1817 {
1818   struct binding_level *lvl = *(struct binding_level **)arg;
1819
1820   while (lvl)
1821     {
1822       ggc_mark_tree (lvl->names);
1823       ggc_mark_tree (lvl->tags);
1824       ggc_mark_tree (lvl->usings);
1825       ggc_mark_tree (lvl->using_directives);
1826       ggc_mark_tree (lvl->class_shadowed);
1827       ggc_mark_tree (lvl->type_shadowed);
1828       ggc_mark_tree (lvl->shadowed_labels);
1829       ggc_mark_tree (lvl->blocks);
1830       ggc_mark_tree (lvl->this_block);
1831       ggc_mark_tree (lvl->incomplete);
1832       ggc_mark_tree (lvl->dead_vars_from_for);
1833
1834       lvl = lvl->level_chain;
1835     }
1836 }
1837 \f
1838 /* For debugging.  */
1839 static int no_print_functions = 0;
1840 static int no_print_builtins = 0;
1841
1842 void
1843 print_binding_level (lvl)
1844      struct binding_level *lvl;
1845 {
1846   tree t;
1847   int i = 0, len;
1848   fprintf (stderr, " blocks=");
1849   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1850   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1851            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1852   if (lvl->tag_transparent)
1853     fprintf (stderr, " tag-transparent");
1854   if (lvl->more_cleanups_ok)
1855     fprintf (stderr, " more-cleanups-ok");
1856   if (lvl->have_cleanups)
1857     fprintf (stderr, " have-cleanups");
1858   fprintf (stderr, "\n");
1859   if (lvl->names)
1860     {
1861       fprintf (stderr, " names:\t");
1862       /* We can probably fit 3 names to a line?  */
1863       for (t = lvl->names; t; t = TREE_CHAIN (t))
1864         {
1865           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1866             continue;
1867           if (no_print_builtins
1868               && (TREE_CODE (t) == TYPE_DECL)
1869               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1870             continue;
1871
1872           /* Function decls tend to have longer names.  */
1873           if (TREE_CODE (t) == FUNCTION_DECL)
1874             len = 3;
1875           else
1876             len = 2;
1877           i += len;
1878           if (i > 6)
1879             {
1880               fprintf (stderr, "\n\t");
1881               i = len;
1882             }
1883           print_node_brief (stderr, "", t, 0);
1884           if (t == error_mark_node)
1885             break;
1886         }
1887       if (i)
1888         fprintf (stderr, "\n");
1889     }
1890   if (lvl->tags)
1891     {
1892       fprintf (stderr, " tags:\t");
1893       i = 0;
1894       for (t = lvl->tags; t; t = TREE_CHAIN (t))
1895         {
1896           if (TREE_PURPOSE (t) == NULL_TREE)
1897             len = 3;
1898           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1899             len = 2;
1900           else
1901             len = 4;
1902           i += len;
1903           if (i > 5)
1904             {
1905               fprintf (stderr, "\n\t");
1906               i = len;
1907             }
1908           if (TREE_PURPOSE (t) == NULL_TREE)
1909             {
1910               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1911               fprintf (stderr, ">");
1912             }
1913           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1914             print_node_brief (stderr, "", TREE_VALUE (t), 0);
1915           else
1916             {
1917               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1918               print_node_brief (stderr, "", TREE_VALUE (t), 0);
1919               fprintf (stderr, ">");
1920             }
1921         }
1922       if (i)
1923         fprintf (stderr, "\n");
1924     }
1925   if (lvl->class_shadowed)
1926     {
1927       fprintf (stderr, " class-shadowed:");
1928       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1929         {
1930           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1931         }
1932       fprintf (stderr, "\n");
1933     }
1934   if (lvl->type_shadowed)
1935     {
1936       fprintf (stderr, " type-shadowed:");
1937       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1938         {
1939           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1940         }
1941       fprintf (stderr, "\n");
1942     }
1943 }
1944
1945 void
1946 print_other_binding_stack (stack)
1947      struct binding_level *stack;
1948 {
1949   struct binding_level *level;
1950   for (level = stack; level != global_binding_level; level = level->level_chain)
1951     {
1952       fprintf (stderr, "binding level ");
1953       fprintf (stderr, HOST_PTR_PRINTF, level);
1954       fprintf (stderr, "\n");
1955       print_binding_level (level);
1956     }
1957 }
1958
1959 void
1960 print_binding_stack ()
1961 {
1962   struct binding_level *b;
1963   fprintf (stderr, "current_binding_level=");
1964   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1965   fprintf (stderr, "\nclass_binding_level=");
1966   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1967   fprintf (stderr, "\nglobal_binding_level=");
1968   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1969   fprintf (stderr, "\n");
1970   if (class_binding_level)
1971     {
1972       for (b = class_binding_level; b; b = b->level_chain)
1973         if (b == current_binding_level)
1974           break;
1975       if (b)
1976         b = class_binding_level;
1977       else
1978         b = current_binding_level;
1979     }
1980   else
1981     b = current_binding_level;
1982   print_other_binding_stack (b);
1983   fprintf (stderr, "global:\n");
1984   print_binding_level (global_binding_level);
1985 }
1986
1987 /* Namespace binding access routines: The namespace_bindings field of
1988    the identifier is polymorphic, with three possible values:
1989    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
1990    indicating the BINDING_VALUE of global_namespace. */
1991
1992 /* Check whether the a binding for the name to scope is known.
1993    Assumes that the bindings of the name are already a list
1994    of bindings. Returns the binding found, or NULL_TREE. */
1995
1996 static tree
1997 find_binding (name, scope)
1998      tree name;
1999      tree scope;
2000 {
2001   tree iter, prev = NULL_TREE;
2002
2003   scope = ORIGINAL_NAMESPACE (scope);
2004
2005   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2006        iter = TREE_CHAIN (iter))
2007     {
2008       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2009       if (BINDING_SCOPE (iter) == scope)
2010         {
2011           /* Move binding found to the front of the list, so
2012              subsequent lookups will find it faster. */
2013           if (prev)
2014             {
2015               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2016               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2017               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2018             }
2019           return iter;
2020         }
2021       prev = iter;
2022     }
2023   return NULL_TREE;
2024 }
2025
2026 /* Always returns a binding for name in scope. If the
2027    namespace_bindings is not a list, convert it to one first.
2028    If no binding is found, make a new one. */
2029
2030 tree
2031 binding_for_name (name, scope)
2032      tree name;
2033      tree scope;
2034 {
2035   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2036   tree result;
2037
2038   scope = ORIGINAL_NAMESPACE (scope);
2039
2040   if (b && TREE_CODE (b) != CPLUS_BINDING)
2041     {
2042       /* Get rid of optimization for global scope. */
2043       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2044       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2045       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2046     }
2047   if (b && (result = find_binding (name, scope)))
2048     return result;
2049   /* Not found, make a new one. */
2050   result = make_node (CPLUS_BINDING);
2051   TREE_CHAIN (result) = b;
2052   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2053   BINDING_SCOPE (result) = scope;
2054   BINDING_TYPE (result) = NULL_TREE;
2055   BINDING_VALUE (result) = NULL_TREE;
2056   return result;
2057 }
2058
2059 /* Return the binding value for name in scope, considering that
2060    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2061
2062 tree
2063 namespace_binding (name, scope)
2064      tree name;
2065      tree scope;
2066 {
2067   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2068   if (b == NULL_TREE)
2069     return NULL_TREE;
2070   if (scope == NULL_TREE)
2071     scope = global_namespace;
2072   if (TREE_CODE (b) != CPLUS_BINDING)
2073     return (scope == global_namespace) ? b : NULL_TREE;
2074   name = find_binding (name,scope);
2075   if (name == NULL_TREE)
2076     return name;
2077   return BINDING_VALUE (name);
2078 }
2079
2080 /* Set the binding value for name in scope. If modifying the binding
2081    of global_namespace is attempted, try to optimize it. */
2082
2083 void
2084 set_namespace_binding (name, scope, val)
2085      tree name;
2086      tree scope;
2087      tree val;
2088 {
2089   tree b;
2090
2091   if (scope == NULL_TREE)
2092     scope = global_namespace;
2093
2094   if (scope == global_namespace)
2095     {
2096       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2097       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2098         {
2099           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2100           return;
2101         }
2102     }
2103   b = binding_for_name (name, scope);
2104   BINDING_VALUE (b) = val;
2105 }
2106
2107 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2108    select a name that is unique to this compilation unit.  */
2109
2110 void
2111 push_namespace (name)
2112      tree name;
2113 {
2114   tree d = NULL_TREE;
2115   int need_new = 1;
2116   int implicit_use = 0;
2117   int global = 0;
2118   if (!global_namespace)
2119     {
2120       /* This must be ::. */
2121       my_friendly_assert (name == get_identifier ("::"), 377);
2122       global = 1;
2123     }
2124   else if (!name)
2125     {
2126       /* The name of anonymous namespace is unique for the translation
2127          unit.  */
2128       if (!anonymous_namespace_name)
2129         anonymous_namespace_name = get_file_function_name ('N');
2130       name = anonymous_namespace_name;
2131       d = IDENTIFIER_NAMESPACE_VALUE (name);
2132       if (d)
2133         /* Reopening anonymous namespace.  */
2134         need_new = 0;
2135       implicit_use = 1;
2136     }
2137   else if (current_namespace == global_namespace
2138            && name == DECL_NAME (std_node))
2139     {
2140       in_std++;
2141       return;
2142     }
2143   else
2144     {
2145       /* Check whether this is an extended namespace definition. */
2146       d = IDENTIFIER_NAMESPACE_VALUE (name);
2147       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2148         {
2149           need_new = 0;
2150           if (DECL_NAMESPACE_ALIAS (d))
2151             {
2152               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2153                         d, DECL_NAMESPACE_ALIAS (d));
2154               d = DECL_NAMESPACE_ALIAS (d);
2155             }
2156         }
2157     }
2158
2159   if (need_new)
2160     {
2161       /* Make a new namespace, binding the name to it. */
2162       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2163       /* The global namespace is not pushed, and the global binding
2164          level is set elsewhere.  */
2165       if (!global)
2166         {
2167           d = pushdecl (d);
2168           pushlevel (0);
2169           declare_namespace_level ();
2170           NAMESPACE_LEVEL (d) = current_binding_level;
2171         }
2172     }
2173   else
2174     resume_binding_level (NAMESPACE_LEVEL (d));
2175
2176   if (implicit_use)
2177     do_using_directive (d);
2178   /* Enter the name space. */
2179   current_namespace = d;
2180 }
2181
2182 /* Pop from the scope of the current namespace.  */
2183
2184 void
2185 pop_namespace ()
2186 {
2187   if (current_namespace == global_namespace)
2188     {
2189       my_friendly_assert (in_std>0, 980421);
2190       in_std--;
2191       return;
2192     }
2193   current_namespace = CP_DECL_CONTEXT (current_namespace);
2194   /* The binding level is not popped, as it might be re-opened later.  */
2195   suspend_binding_level ();
2196 }
2197
2198 /* Push into the scope of the namespace NS, even if it is deeply
2199    nested within another namespace.  */
2200
2201 void
2202 push_nested_namespace (ns)
2203      tree ns;
2204 {
2205   if (ns == global_namespace)
2206     push_to_top_level ();
2207   else
2208     {
2209       push_nested_namespace (CP_DECL_CONTEXT (ns));
2210       push_namespace (DECL_NAME (ns));
2211     }
2212 }
2213
2214 /* Pop back from the scope of the namespace NS, which was previously
2215    entered with push_nested_namespace.  */
2216
2217 void
2218 pop_nested_namespace (ns)
2219      tree ns;
2220 {
2221   while (ns != global_namespace)
2222     {
2223       pop_namespace ();
2224       ns = CP_DECL_CONTEXT (ns);
2225     }
2226
2227   pop_from_top_level ();
2228 }
2229
2230 \f
2231 /* Subroutines for reverting temporarily to top-level for instantiation
2232    of templates and such.  We actually need to clear out the class- and
2233    local-value slots of all identifiers, so that only the global values
2234    are at all visible.  Simply setting current_binding_level to the global
2235    scope isn't enough, because more binding levels may be pushed.  */
2236 struct saved_scope *scope_chain;
2237
2238 /* Mark ST for GC.  */
2239
2240 static void
2241 mark_stmt_tree (st)
2242      struct stmt_tree *st;
2243 {
2244   ggc_mark_tree (st->x_last_stmt);
2245   ggc_mark_tree (st->x_last_expr_type);
2246 }
2247
2248 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2249
2250 static void
2251 mark_saved_scope (arg)
2252      void *arg;
2253 {
2254   struct saved_scope *t = *(struct saved_scope **)arg;
2255   while (t)
2256     {
2257       mark_binding_level (&t->class_bindings);
2258       ggc_mark_tree (t->old_bindings);
2259       ggc_mark_tree (t->old_namespace);
2260       ggc_mark_tree (t->class_name);
2261       ggc_mark_tree (t->class_type);
2262       ggc_mark_tree (t->access_specifier);
2263       ggc_mark_tree (t->function_decl);
2264       if (t->lang_base)
2265         ggc_mark_tree_varray (t->lang_base);
2266       ggc_mark_tree (t->lang_name);
2267       ggc_mark_tree (t->x_function_parms);
2268       ggc_mark_tree (t->template_parms);
2269       ggc_mark_tree (t->x_previous_class_type);
2270       ggc_mark_tree (t->x_previous_class_values);
2271       ggc_mark_tree (t->x_saved_tree);
2272
2273       mark_stmt_tree (&t->x_stmt_tree);
2274       mark_binding_level (&t->bindings);
2275       t = t->prev;
2276     }
2277 }
2278
2279 static tree
2280 store_bindings (names, old_bindings)
2281      tree names, old_bindings;
2282 {
2283   tree t;
2284   for (t = names; t; t = TREE_CHAIN (t))
2285     {
2286       tree binding, t1, id;
2287
2288       if (TREE_CODE (t) == TREE_LIST)
2289         id = TREE_PURPOSE (t);
2290       else
2291         id = DECL_NAME (t);
2292
2293       if (!id
2294           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2295              we have no IDENTIFIER_BINDING if we have left the class
2296              scope, but cached the class-level declarations.  */
2297           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2298         continue;
2299
2300       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2301         if (TREE_VEC_ELT (t1, 0) == id)
2302           goto skip_it;
2303
2304       binding = make_tree_vec (4);
2305
2306       if (id)
2307         {
2308           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2309           TREE_VEC_ELT (binding, 0) = id;
2310           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2311           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2312           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2313           IDENTIFIER_BINDING (id) = NULL_TREE;
2314           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2315         }
2316       TREE_CHAIN (binding) = old_bindings;
2317       old_bindings = binding;
2318     skip_it:
2319       ;
2320     }
2321   return old_bindings;
2322 }
2323
2324 void
2325 maybe_push_to_top_level (pseudo)
2326      int pseudo;
2327 {
2328   struct saved_scope *s;
2329   struct binding_level *b;
2330   tree old_bindings;
2331   int need_pop;
2332
2333   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2334
2335   b = scope_chain ? current_binding_level : 0;
2336
2337   /* If we're in the middle of some function, save our state.  */
2338   if (cfun)
2339     {
2340       need_pop = 1;
2341       push_function_context_to (NULL_TREE);
2342     }
2343   else
2344     need_pop = 0;
2345
2346   old_bindings = NULL_TREE;
2347   if (scope_chain && previous_class_type)
2348     old_bindings = store_bindings (previous_class_values, old_bindings);
2349
2350   /* Have to include global_binding_level, because class-level decls
2351      aren't listed anywhere useful.  */
2352   for (; b; b = b->level_chain)
2353     {
2354       tree t;
2355
2356       /* Template IDs are inserted into the global level. If they were
2357          inserted into namespace level, finish_file wouldn't find them
2358          when doing pending instantiations. Therefore, don't stop at
2359          namespace level, but continue until :: .  */
2360       if (b == global_binding_level || (pseudo && b->pseudo_global))
2361         break;
2362
2363       old_bindings = store_bindings (b->names, old_bindings);
2364       /* We also need to check class_shadowed to save class-level type
2365          bindings, since pushclass doesn't fill in b->names.  */
2366       if (b->parm_flag == 2)
2367         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2368
2369       /* Unwind type-value slots back to top level.  */
2370       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2371         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2372     }
2373   s->prev = scope_chain;
2374   s->old_bindings = old_bindings;
2375   s->bindings = b;
2376   s->need_pop_function_context = need_pop;
2377   s->function_decl = current_function_decl;
2378
2379   scope_chain = s;
2380   current_function_decl = NULL_TREE;
2381   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2382   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2383   current_lang_name = lang_name_cplusplus;
2384   strict_prototype = strict_prototypes_lang_cplusplus;
2385   current_namespace = global_namespace;
2386 }
2387
2388 void
2389 push_to_top_level ()
2390 {
2391   maybe_push_to_top_level (0);
2392 }
2393
2394 void
2395 pop_from_top_level ()
2396 {
2397   struct saved_scope *s = scope_chain;
2398   tree t;
2399
2400   /* Clear out class-level bindings cache.  */
2401   if (previous_class_type)
2402     invalidate_class_lookup_cache ();
2403
2404   VARRAY_FREE (current_lang_base);
2405
2406   scope_chain = s->prev;
2407   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2408     {
2409       tree id = TREE_VEC_ELT (t, 0);
2410       if (id)
2411         {
2412           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2413           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2414           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2415         }
2416     }
2417
2418   if (current_lang_name == lang_name_cplusplus)
2419     strict_prototype = strict_prototypes_lang_cplusplus;
2420   else if (current_lang_name == lang_name_c)
2421     strict_prototype = strict_prototypes_lang_c;
2422
2423   /* If we were in the middle of compiling a function, restore our
2424      state.  */
2425   if (s->need_pop_function_context)
2426     pop_function_context_from (NULL_TREE);
2427   current_function_decl = s->function_decl;
2428
2429   free (s);
2430 }
2431 \f
2432 /* Push a definition of struct, union or enum tag "name".
2433    into binding_level "b".   "type" should be the type node,
2434    We assume that the tag "name" is not already defined.
2435
2436    Note that the definition may really be just a forward reference.
2437    In that case, the TYPE_SIZE will be a NULL_TREE.
2438
2439    C++ gratuitously puts all these tags in the name space.  */
2440
2441 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2442    record the shadowed value for this binding contour.  TYPE is
2443    the type that ID maps to.  */
2444
2445 static void
2446 set_identifier_type_value_with_scope (id, type, b)
2447      tree id;
2448      tree type;
2449      struct binding_level *b;
2450 {
2451   if (!b->namespace_p)
2452     {
2453       /* Shadow the marker, not the real thing, so that the marker
2454          gets restored later. */
2455       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2456       b->type_shadowed
2457         = tree_cons (id, old_type_value, b->type_shadowed);
2458     }
2459   else
2460     {
2461       tree binding = binding_for_name (id, current_namespace);
2462       BINDING_TYPE (binding) = type;
2463       /* Store marker instead of real type. */
2464       type = global_type_node;
2465     }
2466   SET_IDENTIFIER_TYPE_VALUE (id, type);
2467 }
2468
2469 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2470
2471 void
2472 set_identifier_type_value (id, type)
2473      tree id;
2474      tree type;
2475 {
2476   set_identifier_type_value_with_scope (id, type, current_binding_level);
2477 }
2478
2479 /* Return the type associated with id. */
2480
2481 tree
2482 identifier_type_value (id)
2483      tree id;
2484 {
2485   /* There is no type with that name, anywhere. */
2486   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2487     return NULL_TREE;
2488   /* This is not the type marker, but the real thing. */
2489   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2490     return REAL_IDENTIFIER_TYPE_VALUE (id);
2491   /* Have to search for it. It must be on the global level, now.
2492      Ask lookup_name not to return non-types. */
2493   id = lookup_name_real (id, 2, 1, 0);
2494   if (id)
2495     return TREE_TYPE (id);
2496   return NULL_TREE;
2497 }
2498
2499 /* Pop off extraneous binding levels left over due to syntax errors.
2500
2501    We don't pop past namespaces, as they might be valid.  */
2502
2503 void
2504 pop_everything ()
2505 {
2506 #ifdef DEBUG_CP_BINDING_LEVELS
2507   fprintf (stderr, "XXX entering pop_everything ()\n");
2508 #endif
2509   while (!toplevel_bindings_p ())
2510     {
2511       if (current_binding_level->parm_flag == 2)
2512         pop_nested_class ();
2513       else
2514         poplevel (0, 0, 0);
2515     }
2516 #ifdef DEBUG_CP_BINDING_LEVELS
2517   fprintf (stderr, "XXX leaving pop_everything ()\n");
2518 #endif
2519 }
2520
2521 /* The type TYPE is being declared.  If it is a class template, or a
2522    specialization of a class template, do any processing required and
2523    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2524    being declared a friend.  B is the binding level at which this TYPE
2525    should be bound.
2526
2527    Returns the TYPE_DECL for TYPE, which may have been altered by this
2528    processing.  */
2529
2530 static tree
2531 maybe_process_template_type_declaration (type, globalize, b)
2532      tree type;
2533      int globalize;
2534      struct binding_level* b;
2535 {
2536   tree decl = TYPE_NAME (type);
2537
2538   if (processing_template_parmlist)
2539     /* You can't declare a new template type in a template parameter
2540        list.  But, you can declare a non-template type:
2541
2542          template <class A*> struct S;
2543
2544        is a forward-declaration of `A'.  */
2545     ;
2546   else
2547     {
2548       maybe_check_template_type (type);
2549
2550       my_friendly_assert (IS_AGGR_TYPE (type)
2551                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2552
2553
2554       if (processing_template_decl)
2555         {
2556           /* This may change after the call to
2557              push_template_decl_real, but we want the original value.  */
2558           tree name = DECL_NAME (decl);
2559
2560           decl = push_template_decl_real (decl, globalize);
2561           /* If the current binding level is the binding level for the
2562              template parameters (see the comment in
2563              begin_template_parm_list) and the enclosing level is a class
2564              scope, and we're not looking at a friend, push the
2565              declaration of the member class into the class scope.  In the
2566              friend case, push_template_decl will already have put the
2567              friend into global scope, if appropriate.  */
2568           if (TREE_CODE (type) != ENUMERAL_TYPE
2569               && !globalize && b->pseudo_global
2570               && b->level_chain->parm_flag == 2)
2571             {
2572               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2573               /* Put this tag on the list of tags for the class, since
2574                  that won't happen below because B is not the class
2575                  binding level, but is instead the pseudo-global level.  */
2576               b->level_chain->tags =
2577                 tree_cons (name, type, b->level_chain->tags);
2578               if (TYPE_SIZE (current_class_type) == NULL_TREE)
2579                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2580             }
2581         }
2582     }
2583
2584   return decl;
2585 }
2586
2587 /* In C++, you don't have to write `struct S' to refer to `S'; you
2588    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2589    if the user had written `typedef struct S S'.  Create and return
2590    the TYPE_DECL for TYPE.  */
2591
2592 tree
2593 create_implicit_typedef (name, type)
2594      tree name;
2595      tree type;
2596 {
2597   tree decl;
2598
2599   decl = build_decl (TYPE_DECL, name, type);
2600   SET_DECL_ARTIFICIAL (decl);
2601   /* There are other implicit type declarations, like the one *within*
2602      a class that allows you to write `S::S'.  We must distinguish
2603      amongst these.  */
2604   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2605   TYPE_NAME (type) = decl;
2606
2607   return decl;
2608 }
2609
2610 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2611    Normally put it into the inner-most non-tag-transparent scope,
2612    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2613    The latter is needed for implicit declarations.  */
2614
2615 void
2616 pushtag (name, type, globalize)
2617      tree name, type;
2618      int globalize;
2619 {
2620   register struct binding_level *b;
2621
2622   b = current_binding_level;
2623   while (b->tag_transparent
2624          || (globalize && b->parm_flag == 2))
2625     b = b->level_chain;
2626
2627   b->tags = tree_cons (name, type, b->tags);
2628
2629   if (name)
2630     {
2631       /* Do C++ gratuitous typedefing.  */
2632       if (IDENTIFIER_TYPE_VALUE (name) != type)
2633         {
2634           register tree d = NULL_TREE;
2635           int in_class = 0;
2636           tree context = TYPE_CONTEXT (type);
2637
2638           if (! context)
2639             {
2640               tree cs = current_scope ();
2641
2642               if (! globalize)
2643                 context = cs;
2644               else if (cs != NULL_TREE
2645                        && TREE_CODE_CLASS (TREE_CODE (cs)) == 't')
2646                 /* When declaring a friend class of a local class, we want
2647                    to inject the newly named class into the scope
2648                    containing the local class, not the namespace scope.  */
2649                 context = hack_decl_function_context (get_type_decl (cs));
2650             }
2651           if (!context)
2652             context = current_namespace;
2653
2654           if ((b->pseudo_global && b->level_chain->parm_flag == 2)
2655               || b->parm_flag == 2)
2656             in_class = 1;
2657
2658           if (current_lang_name == lang_name_java)
2659             TYPE_FOR_JAVA (type) = 1;
2660
2661           d = create_implicit_typedef (name, type);
2662           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2663           if (! in_class)
2664             set_identifier_type_value_with_scope (name, type, b);
2665
2666           d = maybe_process_template_type_declaration (type,
2667                                                        globalize, b);
2668
2669           if (b->parm_flag == 2)
2670             {
2671               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2672                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2673                    class.  But if it's a member template class, we
2674                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2675                    is done later.  */
2676                 finish_member_declaration (d);
2677               else
2678                 pushdecl_class_level (d);
2679             }
2680           else
2681             d = pushdecl_with_scope (d, b);
2682
2683           if (ANON_AGGRNAME_P (name))
2684             DECL_IGNORED_P (d) = 1;
2685
2686           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2687           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2688           if (!uses_template_parms (type))
2689             DECL_ASSEMBLER_NAME (d)
2690               = get_identifier (build_overload_name (type, 1, 1));
2691         }
2692       if (b->parm_flag == 2)
2693         {
2694           if (TYPE_SIZE (current_class_type) == NULL_TREE)
2695             CLASSTYPE_TAGS (current_class_type) = b->tags;
2696         }
2697     }
2698
2699   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2700     /* Use the canonical TYPE_DECL for this node.  */
2701     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2702   else
2703     {
2704       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2705          will be the tagged type we just added to the current
2706          binding level.  This fake NULL-named TYPE_DECL node helps
2707          dwarfout.c to know when it needs to output a
2708          representation of a tagged type, and it also gives us a
2709          convenient place to record the "scope start" address for
2710          the tagged type.  */
2711
2712       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2713       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2714     }
2715 }
2716
2717 /* Counter used to create anonymous type names.  */
2718
2719 static int anon_cnt = 0;
2720
2721 /* Return an IDENTIFIER which can be used as a name for
2722    anonymous structs and unions.  */
2723
2724 tree
2725 make_anon_name ()
2726 {
2727   char buf[32];
2728
2729   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2730   return get_identifier (buf);
2731 }
2732
2733 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2734    This keeps dbxout from getting confused.  */
2735
2736 void
2737 clear_anon_tags ()
2738 {
2739   register struct binding_level *b;
2740   register tree tags;
2741   static int last_cnt = 0;
2742
2743   /* Fast out if no new anon names were declared.  */
2744   if (last_cnt == anon_cnt)
2745     return;
2746
2747   b = current_binding_level;
2748   while (b->tag_transparent)
2749     b = b->level_chain;
2750   tags = b->tags;
2751   while (tags)
2752     {
2753       /* A NULL purpose means we have already processed all tags
2754          from here to the end of the list.  */
2755       if (TREE_PURPOSE (tags) == NULL_TREE)
2756         break;
2757       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2758         TREE_PURPOSE (tags) = NULL_TREE;
2759       tags = TREE_CHAIN (tags);
2760     }
2761   last_cnt = anon_cnt;
2762 }
2763 \f
2764 /* Subroutine of duplicate_decls: return truthvalue of whether
2765    or not types of these decls match.
2766
2767    For C++, we must compare the parameter list so that `int' can match
2768    `int&' in a parameter position, but `int&' is not confused with
2769    `const int&'.  */
2770
2771 int
2772 decls_match (newdecl, olddecl)
2773      tree newdecl, olddecl;
2774 {
2775   int types_match;
2776
2777   if (newdecl == olddecl)
2778     return 1;
2779
2780   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2781     /* If the two DECLs are not even the same kind of thing, we're not
2782        interested in their types.  */
2783     return 0;
2784
2785   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2786     {
2787       tree f1 = TREE_TYPE (newdecl);
2788       tree f2 = TREE_TYPE (olddecl);
2789       tree p1 = TYPE_ARG_TYPES (f1);
2790       tree p2 = TYPE_ARG_TYPES (f2);
2791
2792       if (DECL_REAL_CONTEXT (newdecl) != DECL_REAL_CONTEXT (olddecl)
2793           && ! (DECL_LANGUAGE (newdecl) == lang_c
2794                 && DECL_LANGUAGE (olddecl) == lang_c))
2795         return 0;
2796
2797       /* When we parse a static member function definition,
2798          we put together a FUNCTION_DECL which thinks its type
2799          is METHOD_TYPE.  Change that to FUNCTION_TYPE, and
2800          proceed.  */
2801       if (TREE_CODE (f1) == METHOD_TYPE && DECL_STATIC_FUNCTION_P (olddecl))
2802         revert_static_member_fn (&newdecl, &f1, &p1);
2803       else if (TREE_CODE (f2) == METHOD_TYPE
2804                && DECL_STATIC_FUNCTION_P (newdecl))
2805         revert_static_member_fn (&olddecl, &f2, &p2);
2806
2807       /* Here we must take care of the case where new default
2808          parameters are specified.  Also, warn if an old
2809          declaration becomes ambiguous because default
2810          parameters may cause the two to be ambiguous.  */
2811       if (TREE_CODE (f1) != TREE_CODE (f2))
2812         {
2813           if (TREE_CODE (f1) == OFFSET_TYPE)
2814             cp_compiler_error ("`%D' redeclared as member function", newdecl);
2815           else
2816             cp_compiler_error ("`%D' redeclared as non-member function", newdecl);
2817           return 0;
2818         }
2819
2820       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2821         {
2822           if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2823               && p2 == NULL_TREE)
2824             {
2825               types_match = self_promoting_args_p (p1);
2826               if (p1 == void_list_node)
2827                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2828             }
2829           else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2830                    && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2831             {
2832               types_match = self_promoting_args_p (p2);
2833               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2834             }
2835           else
2836             types_match = compparms (p1, p2);
2837         }
2838       else
2839         types_match = 0;
2840     }
2841   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2842     {
2843       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2844                                 DECL_TEMPLATE_PARMS (olddecl)))
2845         return 0;
2846
2847       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2848         types_match = 1;
2849       else
2850         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2851                                    DECL_TEMPLATE_RESULT (newdecl));
2852     }
2853   else
2854     {
2855       if (TREE_TYPE (newdecl) == error_mark_node)
2856         types_match = TREE_TYPE (olddecl) == error_mark_node;
2857       else if (TREE_TYPE (olddecl) == NULL_TREE)
2858         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2859       else if (TREE_TYPE (newdecl) == NULL_TREE)
2860         types_match = 0;
2861       else
2862         types_match = comptypes (TREE_TYPE (newdecl),
2863                                  TREE_TYPE (olddecl),
2864                                  COMPARE_REDECLARATION);
2865     }
2866
2867   return types_match;
2868 }
2869
2870 /* If NEWDECL is `static' and an `extern' was seen previously,
2871    warn about it.  OLDDECL is the previous declaration.
2872
2873    Note that this does not apply to the C++ case of declaring
2874    a variable `extern const' and then later `const'.
2875
2876    Don't complain about built-in functions, since they are beyond
2877    the user's control.  */
2878
2879 static void
2880 warn_extern_redeclared_static (newdecl, olddecl)
2881      tree newdecl, olddecl;
2882 {
2883   static const char *explicit_extern_static_warning
2884     = "`%D' was declared `extern' and later `static'";
2885   static const char *implicit_extern_static_warning
2886     = "`%D' was declared implicitly `extern' and later `static'";
2887
2888   tree name;
2889
2890   if (TREE_CODE (newdecl) == TYPE_DECL
2891       || TREE_CODE (newdecl) == TEMPLATE_DECL)
2892     return;
2893
2894   /* Don't get confused by static member functions; that's a different
2895      use of `static'.  */
2896   if (TREE_CODE (newdecl) == FUNCTION_DECL
2897       && DECL_STATIC_FUNCTION_P (newdecl))
2898     return;
2899
2900   /* If the old declaration was `static', or the new one isn't, then
2901      then everything is OK.  */
2902   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2903     return;
2904
2905   /* It's OK to declare a builtin function as `static'.  */
2906   if (TREE_CODE (olddecl) == FUNCTION_DECL
2907       && DECL_ARTIFICIAL (olddecl))
2908     return;
2909
2910   name = DECL_ASSEMBLER_NAME (newdecl);
2911   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2912               ? implicit_extern_static_warning
2913               : explicit_extern_static_warning, newdecl);
2914   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2915 }
2916
2917 /* Handle when a new declaration NEWDECL has the same name as an old
2918    one OLDDECL in the same binding contour.  Prints an error message
2919    if appropriate.
2920
2921    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2922    Otherwise, return 0.  */
2923
2924 int
2925 duplicate_decls (newdecl, olddecl)
2926      tree newdecl, olddecl;
2927 {
2928   unsigned olddecl_uid = DECL_UID (olddecl);
2929   int olddecl_friend = 0, types_match = 0;
2930   int new_defines_function = 0;
2931
2932   if (newdecl == olddecl)
2933     return 1;
2934
2935   types_match = decls_match (newdecl, olddecl);
2936
2937   /* If either the type of the new decl or the type of the old decl is an
2938      error_mark_node, then that implies that we have already issued an
2939      error (earlier) for some bogus type specification, and in that case,
2940      it is rather pointless to harass the user with yet more error message
2941      about the same declaration, so just pretend the types match here.  */
2942   if (TREE_TYPE (newdecl) == error_mark_node
2943       || TREE_TYPE (olddecl) == error_mark_node)
2944     types_match = 1;
2945
2946   /* Check for redeclaration and other discrepancies. */
2947   if (TREE_CODE (olddecl) == FUNCTION_DECL
2948       && DECL_ARTIFICIAL (olddecl))
2949     {
2950       if (TREE_CODE (newdecl) != FUNCTION_DECL)
2951         {
2952           /* If you declare a built-in or predefined function name as static,
2953              the old definition is overridden, but optionally warn this was a
2954              bad choice of name.  */
2955           if (! TREE_PUBLIC (newdecl))
2956             {
2957               if (warn_shadow)
2958                 cp_warning ("shadowing %s function `%#D'",
2959                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2960                             olddecl);
2961               /* Discard the old built-in function.  */
2962               return 0;
2963             }
2964           /* If the built-in is not ansi, then programs can override
2965              it even globally without an error.  */
2966           else if (! DECL_BUILT_IN (olddecl))
2967             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2968                         olddecl, newdecl);
2969           else
2970             {
2971               cp_error ("declaration of `%#D'", newdecl);
2972               cp_error ("conflicts with built-in declaration `%#D'",
2973                         olddecl);
2974             }
2975           return 0;
2976         }
2977       else if (!types_match)
2978         {
2979           if ((DECL_LANGUAGE (newdecl) == lang_c
2980                && DECL_LANGUAGE (olddecl) == lang_c)
2981               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
2982                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
2983             {
2984               /* A near match; override the builtin.  */
2985
2986               if (TREE_PUBLIC (newdecl))
2987                 {
2988                   cp_warning ("new declaration `%#D'", newdecl);
2989                   cp_warning ("ambiguates built-in declaration `%#D'",
2990                               olddecl);
2991                 }
2992               else if (warn_shadow)
2993                 cp_warning ("shadowing %s function `%#D'",
2994                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2995                             olddecl);
2996             }
2997           else
2998             /* Discard the old built-in function.  */
2999             return 0;
3000         }
3001
3002       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3003         {
3004           /* If a builtin function is redeclared as `static', merge
3005              the declarations, but make the original one static.  */
3006           DECL_THIS_STATIC (olddecl) = 1;
3007           TREE_PUBLIC (olddecl) = 0;
3008
3009           /* Make the olddeclaration consistent with the new one so that
3010              all remnants of the builtin-ness of this function will be
3011              banished.  */
3012           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3013           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3014           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3015           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3016                                        newdecl);
3017         }
3018     }
3019   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3020     {
3021       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3022            && TREE_CODE (newdecl) != TYPE_DECL
3023            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3024                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3025           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3026               && TREE_CODE (olddecl) != TYPE_DECL
3027               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3028                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3029                         == TYPE_DECL))))
3030         {
3031           /* We do nothing special here, because C++ does such nasty
3032              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3033              get shadowed, and know that if we need to find a TYPE_DECL
3034              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3035              slot of the identifier.  */
3036           return 0;
3037         }
3038
3039       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3040            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3041           || (TREE_CODE (olddecl) == FUNCTION_DECL
3042               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3043         return 0;
3044
3045       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3046       if (TREE_CODE (olddecl) == TREE_LIST)
3047         olddecl = TREE_VALUE (olddecl);
3048       cp_error_at ("previous declaration of `%#D'", olddecl);
3049
3050       /* New decl is completely inconsistent with the old one =>
3051          tell caller to replace the old one.  */
3052
3053       return 0;
3054     }
3055   else if (!types_match)
3056     {
3057       if (DECL_REAL_CONTEXT (newdecl) != DECL_REAL_CONTEXT (olddecl))
3058         /* These are certainly not duplicate declarations; they're
3059            from different scopes.  */
3060         return 0;
3061
3062       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3063         {
3064           /* The name of a class template may not be declared to refer to
3065              any other template, class, function, object, namespace, value,
3066              or type in the same scope.  */
3067           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3068               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3069             {
3070               cp_error ("declaration of template `%#D'", newdecl);
3071               cp_error_at ("conflicts with previous declaration `%#D'",
3072                            olddecl);
3073             }
3074           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3075                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3076                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3077                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3078                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3079                                            DECL_TEMPLATE_PARMS (olddecl)))
3080             {
3081               cp_error ("new declaration `%#D'", newdecl);
3082               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3083             }
3084           return 0;
3085         }
3086       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3087         {
3088           if (DECL_LANGUAGE (newdecl) == lang_c
3089               && DECL_LANGUAGE (olddecl) == lang_c)
3090             {
3091               cp_error ("declaration of C function `%#D' conflicts with",
3092                         newdecl);
3093               cp_error_at ("previous declaration `%#D' here", olddecl);
3094             }
3095           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3096                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3097             {
3098               cp_error ("new declaration `%#D'", newdecl);
3099               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3100             }
3101           else
3102             return 0;
3103         }
3104
3105       /* Already complained about this, so don't do so again.  */
3106       else if (current_class_type == NULL_TREE
3107           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3108         {
3109           cp_error ("conflicting types for `%#D'", newdecl);
3110           cp_error_at ("previous declaration as `%#D'", olddecl);
3111         }
3112     }
3113   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3114             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3115                  && (!DECL_TEMPLATE_INFO (newdecl)
3116                      || (DECL_TI_TEMPLATE (newdecl)
3117                          != DECL_TI_TEMPLATE (olddecl))))
3118                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3119                     && (!DECL_TEMPLATE_INFO (olddecl)
3120                         || (DECL_TI_TEMPLATE (olddecl)
3121                             != DECL_TI_TEMPLATE (newdecl))))))
3122     /* It's OK to have a template specialization and a non-template
3123        with the same type, or to have specializations of two
3124        different templates with the same type.  Note that if one is a
3125        specialization, and the other is an instantiation of the same
3126        template, that we do not exit at this point.  That situation
3127        can occur if we instantiate a template class, and then
3128        specialize one of its methods.  This situation is legal, but
3129        the declarations must be merged in the usual way.  */
3130     return 0;
3131   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3132            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3133                 && !DECL_USE_TEMPLATE (newdecl))
3134                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3135                    && !DECL_USE_TEMPLATE (olddecl))))
3136     /* One of the declarations is a template instantiation, and the
3137        other is not a template at all.  That's OK.  */
3138     return 0;
3139   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3140            && DECL_NAMESPACE_ALIAS (newdecl)
3141            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3142     /* Redeclaration of namespace alias, ignore it. */
3143     return 1;
3144   else
3145     {
3146       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3147       if (errmsg)
3148         {
3149           cp_error (errmsg, newdecl);
3150           if (DECL_NAME (olddecl) != NULL_TREE)
3151             cp_error_at ((DECL_INITIAL (olddecl)
3152                           && namespace_bindings_p ())
3153                          ? "`%#D' previously defined here"
3154                          : "`%#D' previously declared here", olddecl);
3155         }
3156       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3157                && DECL_INITIAL (olddecl) != NULL_TREE
3158                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3159                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3160         {
3161           /* Prototype decl follows defn w/o prototype.  */
3162           cp_warning_at ("prototype for `%#D'", newdecl);
3163           cp_warning_at ("follows non-prototype definition here", olddecl);
3164         }
3165       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3166                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3167         {
3168           /* extern "C" int foo ();
3169              int foo () { bar (); }
3170              is OK.  */
3171           if (current_lang_stack
3172               == &VARRAY_TREE (current_lang_base, 0))
3173             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3174           else
3175             {
3176               cp_error_at ("previous declaration of `%#D' with %L linkage",
3177                            olddecl, DECL_LANGUAGE (olddecl));
3178               cp_error ("conflicts with new declaration with %L linkage",
3179                         DECL_LANGUAGE (newdecl));
3180             }
3181         }
3182
3183       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3184         ;
3185       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3186         {
3187           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3188           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3189           int i = 1;
3190
3191           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3192             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3193
3194           for (; t1 && t1 != void_list_node;
3195                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3196             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3197               {
3198                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3199                                            TREE_PURPOSE (t2)))
3200                   {
3201                     if (pedantic)
3202                       {
3203                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3204                                     i, newdecl);
3205                         cp_pedwarn_at ("after previous specification in `%#D'",
3206                                        olddecl);
3207                       }
3208                   }
3209                 else
3210                   {
3211                     cp_error ("default argument given for parameter %d of `%#D'",
3212                               i, newdecl);
3213                     cp_error_at ("after previous specification in `%#D'",
3214                                  olddecl);
3215                   }
3216               }
3217
3218           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3219               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3220             {
3221               cp_warning ("`%#D' was used before it was declared inline",
3222                           newdecl);
3223               cp_warning_at ("previous non-inline declaration here",
3224                              olddecl);
3225             }
3226         }
3227     }
3228
3229   /* If new decl is `static' and an `extern' was seen previously,
3230      warn about it.  */
3231   warn_extern_redeclared_static (newdecl, olddecl);
3232
3233   /* We have committed to returning 1 at this point.  */
3234   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3235     {
3236       /* Now that functions must hold information normally held
3237          by field decls, there is extra work to do so that
3238          declaration information does not get destroyed during
3239          definition.  */
3240       if (DECL_VINDEX (olddecl))
3241         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3242       if (DECL_CONTEXT (olddecl))
3243         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3244       if (DECL_CLASS_CONTEXT (olddecl))
3245         DECL_CLASS_CONTEXT (newdecl) = DECL_CLASS_CONTEXT (olddecl);
3246       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3247         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3248       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3249       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3250       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3251       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3252       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3253       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3254       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3255
3256       /* Optionally warn about more than one declaration for the same
3257          name, but don't warn about a function declaration followed by a
3258          definition.  */
3259       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3260           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3261           /* Don't warn about extern decl followed by definition. */
3262           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3263           /* Don't warn about friends, let add_friend take care of it. */
3264           && ! DECL_FRIEND_P (newdecl))
3265         {
3266           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3267           cp_warning_at ("previous declaration of `%D'", olddecl);
3268         }
3269     }
3270
3271   /* Deal with C++: must preserve virtual function table size.  */
3272   if (TREE_CODE (olddecl) == TYPE_DECL)
3273     {
3274       register tree newtype = TREE_TYPE (newdecl);
3275       register tree oldtype = TREE_TYPE (olddecl);
3276
3277       if (newtype != error_mark_node && oldtype != error_mark_node
3278           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3279         {
3280           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3281           CLASSTYPE_FRIEND_CLASSES (newtype)
3282             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3283         }
3284     }
3285
3286   /* Copy all the DECL_... slots specified in the new decl
3287      except for any that we copy here from the old type.  */
3288   DECL_MACHINE_ATTRIBUTES (newdecl)
3289     = merge_machine_decl_attributes (olddecl, newdecl);
3290
3291   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3292     {
3293       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3294                              DECL_TEMPLATE_RESULT (olddecl)))
3295         cp_error ("invalid redeclaration of %D", newdecl);
3296       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3297       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3298         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3299                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3300
3301       return 1;
3302     }
3303
3304   if (types_match)
3305     {
3306       /* Automatically handles default parameters.  */
3307       tree oldtype = TREE_TYPE (olddecl);
3308       tree newtype;
3309
3310       /* Merge the data types specified in the two decls.  */
3311       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3312
3313       if (TREE_CODE (newdecl) == VAR_DECL)
3314         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3315       /* Do this after calling `common_type' so that default
3316          parameters don't confuse us.  */
3317       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3318           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3319               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3320         {
3321           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3322                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3323           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3324                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3325
3326           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3327               && DECL_SOURCE_LINE (olddecl) != 0
3328               && flag_exceptions
3329               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3330                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3331             {
3332               cp_error ("declaration of `%F' throws different exceptions",
3333                         newdecl);
3334               cp_error_at ("than previous declaration `%F'", olddecl);
3335             }
3336         }
3337       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3338
3339       /* Lay the type out, unless already done.  */
3340       if (! same_type_p (newtype, oldtype)
3341           && TREE_TYPE (newdecl) != error_mark_node
3342           && !(processing_template_decl && uses_template_parms (newdecl)))
3343         layout_type (TREE_TYPE (newdecl));
3344
3345       if ((TREE_CODE (newdecl) == VAR_DECL
3346            || TREE_CODE (newdecl) == PARM_DECL
3347            || TREE_CODE (newdecl) == RESULT_DECL
3348            || TREE_CODE (newdecl) == FIELD_DECL
3349            || TREE_CODE (newdecl) == TYPE_DECL)
3350           && !(processing_template_decl && uses_template_parms (newdecl)))
3351         layout_decl (newdecl, 0);
3352
3353       /* Merge the type qualifiers.  */
3354       if (TREE_READONLY (newdecl))
3355         TREE_READONLY (olddecl) = 1;
3356       if (TREE_THIS_VOLATILE (newdecl))
3357         TREE_THIS_VOLATILE (olddecl) = 1;
3358
3359       /* Merge the initialization information.  */
3360       if (DECL_INITIAL (newdecl) == NULL_TREE
3361           && DECL_INITIAL (olddecl) != NULL_TREE)
3362         {
3363           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3364           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3365           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3366           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3367               && DECL_LANG_SPECIFIC (newdecl)
3368               && DECL_LANG_SPECIFIC (olddecl))
3369             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3370         }
3371
3372       /* Merge the section attribute.
3373          We want to issue an error if the sections conflict but that must be
3374          done later in decl_attributes since we are called before attributes
3375          are assigned.  */
3376       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3377         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3378
3379       /* Keep the old rtl since we can safely use it.  */
3380       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3381
3382       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3383         {
3384           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3385             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3386           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3387             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3388           DECL_NO_LIMIT_STACK (newdecl)
3389             |= DECL_NO_LIMIT_STACK (olddecl);
3390         }
3391     }
3392   /* If cannot merge, then use the new type and qualifiers,
3393      and don't preserve the old rtl.  */
3394   else
3395     {
3396       /* Clean out any memory we had of the old declaration.  */
3397       tree oldstatic = value_member (olddecl, static_aggregates);
3398       if (oldstatic)
3399         TREE_VALUE (oldstatic) = error_mark_node;
3400
3401       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3402       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3403       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3404       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3405     }
3406
3407   /* Merge the storage class information.  */
3408   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3409   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3410   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3411   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3412   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3413   if (! DECL_EXTERNAL (olddecl))
3414     DECL_EXTERNAL (newdecl) = 0;
3415
3416   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3417     {
3418       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3419       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3420       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3421       DECL_TEMPLATE_INSTANTIATED (newdecl)
3422         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3423       /* Don't really know how much of the language-specific
3424          values we should copy from old to new.  */
3425       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3426       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3427       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3428       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3429       olddecl_friend = DECL_FRIEND_P (olddecl);
3430
3431       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3432       if (TREE_CODE (newdecl) == FUNCTION_DECL
3433           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3434         DECL_BEFRIENDING_CLASSES (newdecl)
3435           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3436                      DECL_BEFRIENDING_CLASSES (olddecl));
3437     }
3438
3439   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3440     {
3441       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3442           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3443         {
3444           /* If newdecl is not a specialization, then it is not a
3445              template-related function at all.  And that means that we
3446              shoud have exited above, returning 0.  */
3447           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3448                               0);
3449
3450           if (TREE_USED (olddecl))
3451             /* From [temp.expl.spec]:
3452
3453                If a template, a member template or the member of a class
3454                template is explicitly specialized then that
3455                specialization shall be declared before the first use of
3456                that specialization that would cause an implicit
3457                instantiation to take place, in every translation unit in
3458                which such a use occurs.  */
3459             cp_error ("explicit specialization of %D after first use",
3460                       olddecl);
3461
3462           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3463         }
3464       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3465
3466       /* If either decl says `inline', this fn is inline, unless its
3467          definition was passed already.  */
3468       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3469         DECL_INLINE (olddecl) = 1;
3470       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3471
3472       if (! types_match)
3473         {
3474           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3475           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3476           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3477         }
3478       if (! types_match || new_defines_function)
3479         {
3480           /* These need to be copied so that the names are available.
3481              Note that if the types do match, we'll preserve inline
3482              info and other bits, but if not, we won't.  */
3483           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3484           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3485         }
3486       if (new_defines_function)
3487         /* If defining a function declared with other language
3488            linkage, use the previously declared language linkage.  */
3489         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3490       else if (types_match)
3491         {
3492           /* If redeclaring a builtin function, and not a definition,
3493              it stays built in.  */
3494           if (DECL_BUILT_IN (olddecl))
3495             {
3496               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3497               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3498               /* If we're keeping the built-in definition, keep the rtl,
3499                  regardless of declaration matches.  */
3500               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3501             }
3502           else
3503             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3504
3505           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3506           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3507             /* Previously saved insns go together with
3508                the function's previous definition.  */
3509             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3510           /* Don't clear out the arguments if we're redefining a function.  */
3511           if (DECL_ARGUMENTS (olddecl))
3512             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3513         }
3514       if (DECL_LANG_SPECIFIC (olddecl))
3515         DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
3516     }
3517
3518   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3519     {
3520       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3521     }
3522
3523   /* Now preserve various other info from the definition.  */
3524   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3525   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3526   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3527   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3528
3529   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3530     {
3531       int function_size;
3532
3533       function_size = sizeof (struct tree_decl);
3534
3535       bcopy ((char *) newdecl + sizeof (struct tree_common),
3536              (char *) olddecl + sizeof (struct tree_common),
3537              function_size - sizeof (struct tree_common));
3538
3539       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3540         {
3541           /* If newdecl is a template instantiation, it is possible that
3542              the following sequence of events has occurred:
3543
3544              o A friend function was declared in a class template.  The
3545              class template was instantiated.
3546
3547              o The instantiation of the friend declaration was
3548              recorded on the instantiation list, and is newdecl.
3549
3550              o Later, however, instantiate_class_template called pushdecl
3551              on the newdecl to perform name injection.  But, pushdecl in
3552              turn called duplicate_decls when it discovered that another
3553              declaration of a global function with the same name already
3554              existed.
3555
3556              o Here, in duplicate_decls, we decided to clobber newdecl.
3557
3558              If we're going to do that, we'd better make sure that
3559              olddecl, and not newdecl, is on the list of
3560              instantiations so that if we try to do the instantiation
3561              again we won't get the clobbered declaration.  */
3562
3563           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3564           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3565
3566           for (; decls; decls = TREE_CHAIN (decls))
3567             if (TREE_VALUE (decls) == newdecl)
3568               TREE_VALUE (decls) = olddecl;
3569         }
3570     }
3571   else
3572     {
3573       bcopy ((char *) newdecl + sizeof (struct tree_common),
3574              (char *) olddecl + sizeof (struct tree_common),
3575              sizeof (struct tree_decl) - sizeof (struct tree_common)
3576              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3577     }
3578
3579   DECL_UID (olddecl) = olddecl_uid;
3580   if (olddecl_friend)
3581     DECL_FRIEND_P (olddecl) = 1;
3582
3583   /* NEWDECL contains the merged attribute lists.
3584      Update OLDDECL to be the same.  */
3585   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3586
3587   return 1;
3588 }
3589
3590 /* Record a decl-node X as belonging to the current lexical scope.
3591    Check for errors (such as an incompatible declaration for the same
3592    name already seen in the same scope).
3593
3594    Returns either X or an old decl for the same name.
3595    If an old decl is returned, it may have been smashed
3596    to agree with what X says.  */
3597
3598 tree
3599 pushdecl (x)
3600      tree x;
3601 {
3602   register tree t;
3603   register tree name;
3604   int need_new_binding;
3605
3606   /* We shouldn't be calling pushdecl when we're generating RTL for a
3607      function that we already did semantic analysis on previously.  */
3608   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3609                       19990913);
3610
3611   name = DECL_ASSEMBLER_NAME (x);
3612   need_new_binding = 1;
3613
3614   if (DECL_TEMPLATE_PARM_P (x))
3615     /* Template parameters have no context; they are not X::T even
3616        when declared within a class or namespace.  */
3617     ;
3618   else
3619     {
3620       if (current_function_decl && x != current_function_decl
3621           /* A local declaration for a function doesn't constitute
3622              nesting.  */
3623           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3624           /* A local declaration for an `extern' variable is in the
3625              scoped of the current namespace, not the current
3626              function.  */
3627           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3628           /* Don't change DECL_CONTEXT of virtual methods.  */
3629           && (TREE_CODE (x) != FUNCTION_DECL || !DECL_VIRTUAL_P (x))
3630           && !DECL_CONTEXT (x))
3631         DECL_CONTEXT (x) = current_function_decl;
3632       if (!DECL_CONTEXT (x))
3633         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3634
3635       /* If this is the declaration for a namespace-scope function,
3636          but the declaration itself is in a local scope, mark the
3637          declaration.  */
3638       if (TREE_CODE (x) == FUNCTION_DECL
3639           && DECL_NAMESPACE_SCOPE_P (x)
3640           && current_function_decl
3641           && x != current_function_decl)
3642         DECL_LOCAL_FUNCTION_P (x) = 1;
3643     }
3644
3645   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3646      compiler wants to use.  */
3647   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3648       || TREE_CODE (x) == NAMESPACE_DECL)
3649     name = DECL_NAME (x);
3650
3651   if (name)
3652     {
3653 #if 0
3654       /* Not needed...see below.  */
3655       char *file;
3656       int line;
3657 #endif
3658       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3659         name = TREE_OPERAND (name, 0);
3660
3661       /* Namespace-scoped variables are not found in the current level. */
3662       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3663         t = namespace_binding (name, DECL_CONTEXT (x));
3664       else
3665         t = lookup_name_current_level (name);
3666       if (t == error_mark_node)
3667         {
3668           /* error_mark_node is 0 for a while during initialization!  */
3669           t = NULL_TREE;
3670           cp_error_at ("`%#D' used prior to declaration", x);
3671         }
3672
3673       else if (t != NULL_TREE)
3674         {
3675 #if 0
3676           /* This is turned off until I have time to do it right (bpk).  */
3677           /* With the code below that uses it...  */
3678           file = DECL_SOURCE_FILE (t);
3679           line = DECL_SOURCE_LINE (t);
3680 #endif
3681           if (TREE_CODE (t) == PARM_DECL)
3682             {
3683               if (DECL_CONTEXT (t) == NULL_TREE)
3684                 fatal ("parse errors have confused me too much");
3685
3686               /* Check for duplicate params.  */
3687               if (duplicate_decls (x, t))
3688                 return t;
3689             }
3690           else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3691                     || DECL_FUNCTION_TEMPLATE_P (x))
3692                    && is_overloaded_fn (t))
3693             /* Don't do anything just yet. */;
3694           else if (t == wchar_decl_node)
3695             {
3696               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3697                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3698
3699               /* Throw away the redeclaration.  */
3700               return t;
3701             }
3702           else if (TREE_CODE (t) != TREE_CODE (x))
3703             {
3704               if (duplicate_decls (x, t))
3705                 return t;
3706             }
3707           else if (duplicate_decls (x, t))
3708             {
3709 #if 0
3710               /* This is turned off until I have time to do it right (bpk).  */
3711
3712               /* Also warn if they did a prototype with `static' on it, but
3713                  then later left the `static' off.  */
3714               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3715                 {
3716                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3717                     return t;
3718
3719                   if (extra_warnings)
3720                     {
3721                       cp_warning ("`static' missing from declaration of `%D'",
3722                                   t);
3723                       warning_with_file_and_line (file, line,
3724                                                   "previous declaration of `%s'",
3725                                                   decl_as_string (t, 0));
3726                     }
3727
3728                   /* Now fix things so it'll do what they expect.  */
3729                   if (current_function_decl)
3730                     TREE_PUBLIC (current_function_decl) = 0;
3731                 }
3732               /* Due to interference in memory reclamation (X may be
3733                  obstack-deallocated at this point), we must guard against
3734                  one really special case.  [jason: This should be handled
3735                  by start_function]  */
3736               if (current_function_decl == x)
3737                 current_function_decl = t;
3738 #endif
3739               if (TREE_CODE (t) == TYPE_DECL)
3740                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3741               else if (TREE_CODE (t) == FUNCTION_DECL)
3742                 check_default_args (t);
3743
3744               return t;
3745             }
3746           else if (DECL_MAIN_P (x))
3747             {
3748               /* A redeclaration of main, but not a duplicate of the
3749                  previous one.
3750
3751                  [basic.start.main]
3752
3753                  This function shall not be overloaded.  */
3754               cp_error_at ("invalid redeclaration of `%D'", t);
3755               cp_error ("as `%D'", x);
3756               /* We don't try to push this declaration since that
3757                  causes a crash.  */
3758               return x;
3759             }
3760         }
3761
3762       check_template_shadow (x);
3763
3764       /* If this is a function conjured up by the backend, massage it
3765          so it looks friendly.  */
3766       if (TREE_CODE (x) == FUNCTION_DECL
3767           && ! DECL_LANG_SPECIFIC (x))
3768         {
3769           retrofit_lang_decl (x);
3770           DECL_LANGUAGE (x) = lang_c;
3771         }
3772
3773       if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3774         {
3775           t = push_overloaded_decl (x, PUSH_LOCAL);
3776           if (t != x)
3777             return t;
3778           if (!namespace_bindings_p ())
3779             /* We do not need to create a binding for this name;
3780                push_overloaded_decl will have already done so if
3781                necessary.  */
3782             need_new_binding = 0;
3783         }
3784       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3785         {
3786           t = push_overloaded_decl (x, PUSH_GLOBAL);
3787           if (t == x)
3788             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3789           return t;
3790         }
3791
3792       /* If declaring a type as a typedef, copy the type (unless we're
3793          at line 0), and install this TYPE_DECL as the new type's typedef
3794          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3795       if (TREE_CODE (x) == TYPE_DECL)
3796         {
3797           tree type = TREE_TYPE (x);
3798           if (DECL_SOURCE_LINE (x) == 0)
3799             {
3800               if (TYPE_NAME (type) == 0)
3801                 TYPE_NAME (type) = x;
3802             }
3803           else if (type != error_mark_node && TYPE_NAME (type) != x
3804                    /* We don't want to copy the type when all we're
3805                       doing is making a TYPE_DECL for the purposes of
3806                       inlining.  */
3807                    && (!TYPE_NAME (type)
3808                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3809             {
3810               DECL_ORIGINAL_TYPE (x) = type;
3811               type = build_type_copy (type);
3812               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3813               TYPE_NAME (type) = x;
3814               TREE_TYPE (x) = type;
3815             }
3816
3817           if (type != error_mark_node
3818               && TYPE_NAME (type)
3819               && TYPE_IDENTIFIER (type))
3820             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3821                                                   current_binding_level);
3822
3823         }
3824
3825       /* Multiple external decls of the same identifier ought to match.
3826
3827          We get warnings about inline functions where they are defined.
3828          We get warnings about other functions from push_overloaded_decl.
3829
3830          Avoid duplicate warnings where they are used.  */
3831       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3832         {
3833           tree decl;
3834
3835           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3836               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3837                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3838             decl = IDENTIFIER_NAMESPACE_VALUE (name);
3839           else
3840             decl = NULL_TREE;
3841
3842           if (decl
3843               /* If different sort of thing, we already gave an error.  */
3844               && TREE_CODE (decl) == TREE_CODE (x)
3845               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3846             {
3847               cp_pedwarn ("type mismatch with previous external decl", x);
3848               cp_pedwarn_at ("previous external decl of `%#D'", decl);
3849             }
3850         }
3851
3852       /* This name is new in its binding level.
3853          Install the new declaration and return it.  */
3854       if (namespace_bindings_p ())
3855         {
3856           /* Install a global value.  */
3857
3858           /* If the first global decl has external linkage,
3859              warn if we later see static one.  */
3860           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3861             TREE_PUBLIC (name) = 1;
3862
3863           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3864                 && t != NULL_TREE)
3865               /* For an ordinary function, we create a binding from
3866                  the mangled name (i.e., NAME) to the DECL.  But, for
3867                  an `extern "C"' function, the mangled name and the
3868                  ordinary name are the same so we need not do this.  */
3869               && !(TREE_CODE (x) == FUNCTION_DECL &&
3870                    DECL_LANGUAGE (x) == lang_c))
3871             {
3872               if (TREE_CODE (x) == FUNCTION_DECL)
3873                 my_friendly_assert
3874                   ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
3875                   || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
3876               SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3877             }
3878
3879           /* Don't forget if the function was used via an implicit decl.  */
3880           if (IDENTIFIER_IMPLICIT_DECL (name)
3881               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3882             TREE_USED (x) = 1;
3883
3884           /* Don't forget if its address was taken in that way.  */
3885           if (IDENTIFIER_IMPLICIT_DECL (name)
3886               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3887             TREE_ADDRESSABLE (x) = 1;
3888
3889           /* Warn about mismatches against previous implicit decl.  */
3890           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
3891               /* If this real decl matches the implicit, don't complain.  */
3892               && ! (TREE_CODE (x) == FUNCTION_DECL
3893                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
3894             cp_warning
3895               ("`%D' was previously implicitly declared to return `int'", x);
3896
3897           /* If new decl is `static' and an `extern' was seen previously,
3898              warn about it.  */
3899           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
3900             warn_extern_redeclared_static (x, t);
3901         }
3902       else
3903         {
3904           /* Here to install a non-global value.  */
3905           tree oldlocal = IDENTIFIER_VALUE (name);
3906           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
3907
3908           if (need_new_binding)
3909             {
3910               push_local_binding (name, x, 0);
3911               /* Because push_local_binding will hook X on to the
3912                  current_binding_level's name list, we don't want to
3913                  do that again below.  */
3914               need_new_binding = 0;
3915             }
3916
3917           /* If this is a TYPE_DECL, push it into the type value slot.  */
3918           if (TREE_CODE (x) == TYPE_DECL)
3919             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
3920                                                   current_binding_level);
3921
3922           /* Clear out any TYPE_DECL shadowed by a namespace so that
3923              we won't think this is a type.  The C struct hack doesn't
3924              go through namespaces.  */
3925           if (TREE_CODE (x) == NAMESPACE_DECL)
3926             set_identifier_type_value_with_scope (name, NULL_TREE,
3927                                                   current_binding_level);
3928
3929           /* If this is an extern function declaration, see if we
3930              have a global definition or declaration for the function.  */
3931           if (oldlocal == NULL_TREE
3932               && DECL_EXTERNAL (x)
3933               && oldglobal != NULL_TREE
3934               && TREE_CODE (x) == FUNCTION_DECL
3935               && TREE_CODE (oldglobal) == FUNCTION_DECL)
3936             {
3937               /* We have one.  Their types must agree.  */
3938               if (decls_match (x, oldglobal))
3939                 /* OK */;
3940               else
3941                 {
3942                   cp_warning ("extern declaration of `%#D' doesn't match", x);
3943                   cp_warning_at ("global declaration `%#D'", oldglobal);
3944                 }
3945             }
3946           /* If we have a local external declaration,
3947              and no file-scope declaration has yet been seen,
3948              then if we later have a file-scope decl it must not be static.  */
3949           if (oldlocal == NULL_TREE
3950               && oldglobal == NULL_TREE
3951               && DECL_EXTERNAL (x)
3952               && TREE_PUBLIC (x))
3953             TREE_PUBLIC (name) = 1;
3954
3955           if (DECL_FROM_INLINE (x))
3956             /* Inline decls shadow nothing.  */;
3957
3958           /* Warn if shadowing an argument at the top level of the body.  */
3959           else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
3960                    && TREE_CODE (oldlocal) == PARM_DECL
3961                    /* Don't complain if it's from an enclosing function.  */
3962                    && DECL_CONTEXT (oldlocal) == current_function_decl
3963                    && TREE_CODE (x) != PARM_DECL)
3964             {
3965               /* Go to where the parms should be and see if we
3966                  find them there.  */
3967               struct binding_level *b = current_binding_level->level_chain;
3968
3969               if (cleanup_label)
3970                 b = b->level_chain;
3971
3972               /* ARM $8.3 */
3973               if (b->parm_flag == 1)
3974                 cp_error ("declaration of `%#D' shadows a parameter", name);
3975             }
3976           else if (warn_shadow && oldlocal != NULL_TREE
3977                    && current_binding_level->is_for_scope
3978                    && !DECL_DEAD_FOR_LOCAL (oldlocal))
3979             {
3980               warning ("variable `%s' shadows local",
3981                        IDENTIFIER_POINTER (name));
3982               cp_warning_at ("  this is the shadowed declaration", oldlocal);
3983             }
3984           /* Maybe warn if shadowing something else.  */
3985           else if (warn_shadow && !DECL_EXTERNAL (x)
3986                    /* No shadow warnings for internally generated vars.  */
3987                    && ! DECL_ARTIFICIAL (x)
3988                    /* No shadow warnings for vars made for inlining.  */
3989                    && ! DECL_FROM_INLINE (x))
3990             {
3991               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
3992                 warning ("declaration of `%s' shadows a parameter",
3993                         IDENTIFIER_POINTER (name));
3994               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
3995                        && current_class_ptr
3996                        && !TREE_STATIC (name))
3997                 warning ("declaration of `%s' shadows a member of `this'",
3998                         IDENTIFIER_POINTER (name));
3999               else if (oldlocal != NULL_TREE)
4000                 warning ("declaration of `%s' shadows previous local",
4001                         IDENTIFIER_POINTER (name));
4002               else if (oldglobal != NULL_TREE)
4003                 /* XXX shadow warnings in outer-more namespaces */
4004                 warning ("declaration of `%s' shadows global declaration",
4005                         IDENTIFIER_POINTER (name));
4006             }
4007         }
4008
4009       if (TREE_CODE (x) == FUNCTION_DECL)
4010         check_default_args (x);
4011
4012       /* Keep count of variables in this level with incomplete type.  */
4013       if (TREE_CODE (x) == VAR_DECL
4014           && TREE_TYPE (x) != error_mark_node
4015           && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
4016                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4017               /* RTTI TD entries are created while defining the type_info.  */
4018               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4019                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4020         current_binding_level->incomplete
4021           = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4022     }
4023
4024   if (need_new_binding)
4025     add_decl_to_level (x,
4026                        DECL_NAMESPACE_SCOPE_P (x)
4027                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4028                        : current_binding_level);
4029
4030   return x;
4031 }
4032
4033 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4034    caller to set DECL_CONTEXT properly.  */
4035
4036 static tree
4037 pushdecl_with_scope (x, level)
4038      tree x;
4039      struct binding_level *level;
4040 {
4041   register struct binding_level *b;
4042   tree function_decl = current_function_decl;
4043
4044   current_function_decl = NULL_TREE;
4045   if (level->parm_flag == 2)
4046     {
4047       b = class_binding_level;
4048       class_binding_level = level;
4049       pushdecl_class_level (x);
4050       class_binding_level = b;
4051     }
4052   else
4053     {
4054       b = current_binding_level;
4055       current_binding_level = level;
4056       x = pushdecl (x);
4057       current_binding_level = b;
4058     }
4059   current_function_decl = function_decl;
4060   return x;
4061 }
4062
4063 /* Like pushdecl, only it places X in the current namespace,
4064    if appropriate.  */
4065
4066 tree
4067 pushdecl_namespace_level (x)
4068      tree x;
4069 {
4070   register struct binding_level *b = current_binding_level;
4071   register tree t;
4072
4073   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4074
4075   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4076      what we want.  */
4077   if (TREE_CODE (x) == TYPE_DECL)
4078     {
4079       tree name = DECL_NAME (x);
4080       tree newval;
4081       tree *ptr = (tree *)0;
4082       for (; b != global_binding_level; b = b->level_chain)
4083         {
4084           tree shadowed = b->type_shadowed;
4085           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4086             if (TREE_PURPOSE (shadowed) == name)
4087               {
4088                 ptr = &TREE_VALUE (shadowed);
4089                 /* Can't break out of the loop here because sometimes
4090                    a binding level will have duplicate bindings for
4091                    PT names.  It's gross, but I haven't time to fix it.  */
4092               }
4093         }
4094       newval = TREE_TYPE (x);
4095       if (ptr == (tree *)0)
4096         {
4097           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4098              up here if this is changed to an assertion.  --KR  */
4099           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4100         }
4101       else
4102         {
4103           *ptr = newval;
4104         }
4105     }
4106   return t;
4107 }
4108
4109 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4110    if appropriate.  */
4111
4112 tree
4113 pushdecl_top_level (x)
4114      tree x;
4115 {
4116   push_to_top_level ();
4117   x = pushdecl_namespace_level (x);
4118   pop_from_top_level ();
4119   return x;
4120 }
4121
4122 /* Make the declaration of X appear in CLASS scope.  */
4123
4124 void
4125 pushdecl_class_level (x)
4126      tree x;
4127 {
4128   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4129      scope looks for the pre-mangled name.  */
4130   register tree name;
4131
4132   if (TREE_CODE (x) == OVERLOAD)
4133     x = OVL_CURRENT (x);
4134   name = DECL_NAME (x);
4135
4136   if (name)
4137     {
4138       push_class_level_binding (name, x);
4139       if (TREE_CODE (x) == TYPE_DECL)
4140         set_identifier_type_value (name, TREE_TYPE (x));
4141     }
4142   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4143     {
4144       tree f;
4145
4146       for (f = TYPE_FIELDS (TREE_TYPE (x));
4147            f;
4148            f = TREE_CHAIN (f))
4149         pushdecl_class_level (f);
4150     }
4151 }
4152
4153 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4154    DECL, or a modified version thereof.  */
4155
4156 tree
4157 maybe_push_decl (decl)
4158      tree decl;
4159 {
4160   tree type = TREE_TYPE (decl);
4161
4162   /* Add this decl to the current binding level, but not if it comes
4163      from another scope, e.g. a static member variable.  TEM may equal
4164      DECL or it may be a previous decl of the same name.  */
4165   if ((TREE_CODE (decl) != PARM_DECL
4166        && DECL_CONTEXT (decl) != NULL_TREE
4167        /* Definitions of namespace members outside their namespace are
4168           possible. */
4169        && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4170       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4171       || TREE_CODE (type) == UNKNOWN_TYPE
4172       /* The declaration of a template specialization does not affect
4173          the functions available for overload resolution, so we do not
4174          call pushdecl.  */
4175       || (TREE_CODE (decl) == FUNCTION_DECL
4176           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4177     return decl;
4178   else
4179     return pushdecl (decl);
4180 }
4181
4182 #if 0
4183 /* This function is used to push the mangled decls for nested types into
4184    the appropriate scope.  Previously pushdecl_top_level was used, but that
4185    is incorrect for members of local classes.  */
4186
4187 void
4188 pushdecl_nonclass_level (x)
4189      tree x;
4190 {
4191   struct binding_level *b = current_binding_level;
4192
4193   my_friendly_assert (b->parm_flag != 2, 180);
4194
4195 #if 0
4196   /* Get out of template binding levels */
4197   while (b->pseudo_global)
4198     b = b->level_chain;
4199 #endif
4200
4201   pushdecl_with_scope (x, b);
4202 }
4203 #endif
4204
4205 /* Make the declaration(s) of X appear in CLASS scope
4206    under the name NAME.  */
4207
4208 void
4209 push_class_level_binding (name, x)
4210      tree name;
4211      tree x;
4212 {
4213   tree binding;
4214   /* The class_binding_level will be NULL if x is a template
4215      parameter name in a member template.  */
4216   if (!class_binding_level)
4217     return;
4218
4219   /* Make sure that this new member does not have the same name
4220      as a template parameter.  */
4221   if (TYPE_BEING_DEFINED (current_class_type))
4222     check_template_shadow (x);
4223
4224   /* If this declaration shadows a declaration from an enclosing
4225      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4226      we leave this class.  Record the shadowed declaration here.  */
4227   binding = IDENTIFIER_BINDING (name);
4228   if (binding
4229       && ((TREE_CODE (x) == OVERLOAD
4230            && BINDING_VALUE (binding)
4231            && is_overloaded_fn (BINDING_VALUE (binding)))
4232           || INHERITED_VALUE_BINDING_P (binding)))
4233     {
4234       tree shadow;
4235       tree old_decl;
4236
4237       /* If the old binding was from a base class, and was for a tag
4238          name, slide it over to make room for the new binding.  The
4239          old binding is still visible if explicitly qualified with a
4240          class-key.  */
4241       if (INHERITED_VALUE_BINDING_P (binding)
4242           && BINDING_VALUE (binding)
4243           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4244           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4245           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4246         {
4247           old_decl = BINDING_TYPE (binding);
4248           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4249           BINDING_VALUE (binding) = NULL_TREE;
4250           INHERITED_VALUE_BINDING_P (binding) = 0;
4251         }
4252       else
4253         old_decl = BINDING_VALUE (binding);
4254
4255       /* There was already a binding for X containing fewer
4256          functions than are named in X.  Find the previous
4257          declaration of X on the class-shadowed list, and update it.  */
4258       for (shadow = class_binding_level->class_shadowed;
4259            shadow;
4260            shadow = TREE_CHAIN (shadow))
4261         if (TREE_PURPOSE (shadow) == name
4262             && TREE_TYPE (shadow) == old_decl)
4263           {
4264             BINDING_VALUE (binding) = x;
4265             INHERITED_VALUE_BINDING_P (binding) = 0;
4266             TREE_TYPE (shadow) = x;
4267             return;
4268           }
4269     }
4270
4271   /* If we didn't replace an existing binding, put the binding on the
4272      stack of bindings for the identifier, and update
4273      IDENTIFIER_CLASS_VALUE.  */
4274   if (push_class_binding (name, x))
4275     {
4276       class_binding_level->class_shadowed
4277         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4278                      class_binding_level->class_shadowed);
4279       /* Record the value we are binding NAME to so that we can know
4280          what to pop later.  */
4281       TREE_TYPE (class_binding_level->class_shadowed) = x;
4282     }
4283 }
4284
4285 /* Insert another USING_DECL into the current binding level,
4286    returning this declaration. If this is a redeclaration,
4287    do nothing and return NULL_TREE.  */
4288
4289 tree
4290 push_using_decl (scope, name)
4291      tree scope;
4292      tree name;
4293 {
4294   tree decl;
4295
4296   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4297   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4298   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4299     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4300       break;
4301   if (decl)
4302     return NULL_TREE;
4303   decl = build_lang_decl (USING_DECL, name, void_type_node);
4304   DECL_INITIAL (decl) = scope;
4305   TREE_CHAIN (decl) = current_binding_level->usings;
4306   current_binding_level->usings = decl;
4307   return decl;
4308 }
4309
4310 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4311    changed (i.e. there was already a directive), or the fresh
4312    TREE_LIST otherwise.  */
4313
4314 tree
4315 push_using_directive (used)
4316      tree used;
4317 {
4318   tree ud = current_binding_level->using_directives;
4319   tree iter, ancestor;
4320
4321   /* Check if we already have this. */
4322   if (purpose_member (used, ud) != NULL_TREE)
4323     return NULL_TREE;
4324
4325   /* Recursively add all namespaces used. */
4326   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4327     push_using_directive (TREE_PURPOSE (iter));
4328
4329   ancestor = namespace_ancestor (current_decl_namespace (), used);
4330   ud = current_binding_level->using_directives;
4331   ud = tree_cons (used, ancestor, ud);
4332   current_binding_level->using_directives = ud;
4333   return ud;
4334 }
4335
4336 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4337    other definitions already in place.  We get around this by making
4338    the value of the identifier point to a list of all the things that
4339    want to be referenced by that name.  It is then up to the users of
4340    that name to decide what to do with that list.
4341
4342    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4343    slot.  It is dealt with the same way.
4344
4345    FLAGS is a bitwise-or of the following values:
4346      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4347                  namespace scope.
4348      PUSH_USING: DECL is being pushed as the result of a using
4349                  declaration.
4350
4351    The value returned may be a previous declaration if we guessed wrong
4352    about what language DECL should belong to (C or C++).  Otherwise,
4353    it's always DECL (and never something that's not a _DECL).  */
4354
4355 tree
4356 push_overloaded_decl (decl, flags)
4357      tree decl;
4358      int flags;
4359 {
4360   tree name = DECL_NAME (decl);
4361   tree old;
4362   tree new_binding;
4363   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4364
4365   if (doing_global)
4366     old = namespace_binding (name, DECL_CONTEXT (decl));
4367   else
4368     old = lookup_name_current_level (name);
4369
4370   if (old)
4371     {
4372       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4373         {
4374           tree t = TREE_TYPE (old);
4375           if (IS_AGGR_TYPE (t) && warn_shadow
4376               && (! DECL_IN_SYSTEM_HEADER (decl)
4377                   || ! DECL_IN_SYSTEM_HEADER (old)))
4378             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4379           old = NULL_TREE;
4380         }
4381       else if (is_overloaded_fn (old))
4382         {
4383           tree tmp;
4384
4385           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4386             {
4387               tree fn = OVL_CURRENT (tmp);
4388
4389               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4390                   && !(flags & PUSH_USING)
4391                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4392                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4393                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4394                           decl, fn);
4395
4396               if (duplicate_decls (decl, fn))
4397                 return fn;
4398             }
4399         }
4400       else
4401         {
4402           cp_error_at ("previous non-function declaration `%#D'", old);
4403           cp_error ("conflicts with function declaration `%#D'", decl);
4404           return decl;
4405         }
4406     }
4407
4408   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4409     {
4410       if (old && TREE_CODE (old) != OVERLOAD)
4411         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4412       else
4413         new_binding = ovl_cons (decl, old);
4414       if (flags & PUSH_USING)
4415         OVL_USED (new_binding) = 1;
4416     }
4417   else
4418     /* NAME is not ambiguous.  */
4419     new_binding = decl;
4420
4421   if (doing_global)
4422     set_namespace_binding (name, current_namespace, new_binding);
4423   else
4424     {
4425       /* We only create an OVERLOAD if there was a previous binding at
4426          this level, or if decl is a template. In the former case, we
4427          need to remove the old binding and replace it with the new
4428          binding.  We must also run through the NAMES on the binding
4429          level where the name was bound to update the chain.  */
4430
4431       if (TREE_CODE (new_binding) == OVERLOAD && old)
4432         {
4433           tree *d;
4434
4435           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4436                *d;
4437                d = &TREE_CHAIN (*d))
4438             if (*d == old
4439                 || (TREE_CODE (*d) == TREE_LIST
4440                     && TREE_VALUE (*d) == old))
4441               {
4442                 if (TREE_CODE (*d) == TREE_LIST)
4443                   /* Just replace the old binding with the new.  */
4444                   TREE_VALUE (*d) = new_binding;
4445                 else
4446                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4447                   *d = tree_cons (NULL_TREE, new_binding,
4448                                   TREE_CHAIN (*d));
4449
4450                 /* And update the CPLUS_BINDING node.  */
4451                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4452                   = new_binding;
4453                 return decl;
4454               }
4455
4456           /* We should always find a previous binding in this case.  */
4457           my_friendly_abort (0);
4458         }
4459
4460       /* Install the new binding.  */
4461       push_local_binding (name, new_binding, flags);
4462     }
4463
4464   return decl;
4465 }
4466 \f
4467 /* Generate an implicit declaration for identifier FUNCTIONID
4468    as a function of type int ().  Print a warning if appropriate.  */
4469
4470 tree
4471 implicitly_declare (functionid)
4472      tree functionid;
4473 {
4474   register tree decl;
4475
4476   /* We used to reuse an old implicit decl here,
4477      but this loses with inline functions because it can clobber
4478      the saved decl chains.  */
4479   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4480
4481   DECL_EXTERNAL (decl) = 1;
4482   TREE_PUBLIC (decl) = 1;
4483
4484   /* ANSI standard says implicit declarations are in the innermost block.
4485      So we record the decl in the standard fashion.  */
4486   pushdecl (decl);
4487   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4488
4489   if (warn_implicit
4490       /* Only one warning per identifier.  */
4491       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4492     {
4493       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4494     }
4495
4496   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4497
4498   return decl;
4499 }
4500
4501 /* Return zero if the declaration NEWDECL is valid
4502    when the declaration OLDDECL (assumed to be for the same name)
4503    has already been seen.
4504    Otherwise return an error message format string with a %s
4505    where the identifier should go.  */
4506
4507 static const char *
4508 redeclaration_error_message (newdecl, olddecl)
4509      tree newdecl, olddecl;
4510 {
4511   if (TREE_CODE (newdecl) == TYPE_DECL)
4512     {
4513       /* Because C++ can put things into name space for free,
4514          constructs like "typedef struct foo { ... } foo"
4515          would look like an erroneous redeclaration.  */
4516       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4517         return 0;
4518       else
4519         return "redefinition of `%#D'";
4520     }
4521   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4522     {
4523       /* If this is a pure function, its olddecl will actually be
4524          the original initialization to `0' (which we force to call
4525          abort()).  Don't complain about redefinition in this case.  */
4526       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4527         return 0;
4528
4529       /* If both functions come from different namespaces, this is not
4530          a redeclaration - this is a conflict with a used function. */
4531       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4532           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4533         return "`%D' conflicts with used function";
4534
4535       /* We'll complain about linkage mismatches in
4536          warn_extern_redeclared_static.  */
4537
4538       /* Defining the same name twice is no good.  */
4539       if (DECL_INITIAL (olddecl) != NULL_TREE
4540           && DECL_INITIAL (newdecl) != NULL_TREE)
4541         {
4542           if (DECL_NAME (olddecl) == NULL_TREE)
4543             return "`%#D' not declared in class";
4544           else
4545             return "redefinition of `%#D'";
4546         }
4547       return 0;
4548     }
4549   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4550     {
4551       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4552            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4553            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4554           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4555               && TYPE_SIZE (TREE_TYPE (newdecl))
4556               && TYPE_SIZE (TREE_TYPE (olddecl))))
4557         return "redefinition of `%#D'";
4558       return 0;
4559     }
4560   else if (toplevel_bindings_p ())
4561     {
4562       /* Objects declared at top level:  */
4563       /* If at least one is a reference, it's ok.  */
4564       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4565         return 0;
4566       /* Reject two definitions.  */
4567       return "redefinition of `%#D'";
4568     }
4569   else
4570     {
4571       /* Objects declared with block scope:  */
4572       /* Reject two definitions, and reject a definition
4573          together with an external reference.  */
4574       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4575         return "redeclaration of `%#D'";
4576       return 0;
4577     }
4578 }
4579 \f
4580 /* Create a new label, named ID.  */
4581
4582 static tree
4583 make_label_decl (id, local_p)
4584      tree id;
4585      int local_p;
4586 {
4587   tree decl;
4588
4589   decl = build_decl (LABEL_DECL, id, void_type_node);
4590   if (expanding_p)
4591     /* Make sure every label has an rtx.  */
4592     label_rtx (decl);
4593
4594   DECL_CONTEXT (decl) = current_function_decl;
4595   DECL_MODE (decl) = VOIDmode;
4596   C_DECLARED_LABEL_FLAG (decl) = local_p;
4597
4598   /* Say where one reference is to the label, for the sake of the
4599      error if it is not defined.  */
4600   DECL_SOURCE_LINE (decl) = lineno;
4601   DECL_SOURCE_FILE (decl) = input_filename;
4602
4603   /* Record the fact that this identifier is bound to this label.  */
4604   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4605
4606   /* Record this label on the list of used labels so that we can check
4607      at the end of the function to see whether or not the label was
4608      actually defined.  */
4609   if ((named_label_uses == NULL || named_label_uses->label_decl != decl)
4610       && (named_label_uses == NULL
4611           || named_label_uses->names_in_scope != current_binding_level->names
4612           || named_label_uses->label_decl != decl))
4613     {
4614       struct named_label_list *new_ent;
4615       new_ent
4616         = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4617       new_ent->label_decl = decl;
4618       new_ent->names_in_scope = current_binding_level->names;
4619       new_ent->binding_level = current_binding_level;
4620       new_ent->lineno_o_goto = lineno;
4621       new_ent->filename_o_goto = input_filename;
4622       new_ent->next = named_label_uses;
4623       named_label_uses = new_ent;
4624     }
4625
4626   return decl;
4627 }
4628
4629 /* Look for a label named ID in the current function.  If one cannot
4630    be found, create one.  (We keep track of used, but undefined,
4631    labels, and complain about them at the end of a function.)  */
4632
4633 tree
4634 lookup_label (id)
4635      tree id;
4636 {
4637   tree decl;
4638
4639   /* You can't use labels at global scope.  */
4640   if (current_function_decl == NULL_TREE)
4641     {
4642       error ("label `%s' referenced outside of any function",
4643              IDENTIFIER_POINTER (id));
4644       return NULL_TREE;
4645     }
4646
4647   /* See if we've already got this label.  */
4648   decl = IDENTIFIER_LABEL_VALUE (id);
4649   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4650     return decl;
4651
4652   /* Record this label on the list of labels used in this function.
4653      We do this before calling make_label_decl so that we get the
4654      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4655   named_labels = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4656                             named_labels);
4657   /* We need a new label.  */
4658   decl = make_label_decl (id, /*local_p=*/0);
4659   /* Now fill in the information we didn't have before.  */
4660   TREE_VALUE (named_labels) = decl;
4661
4662   return decl;
4663 }
4664
4665 /* Declare a local label named ID.  */
4666
4667 tree
4668 declare_local_label (id)
4669      tree id;
4670 {
4671   tree decl;
4672
4673   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4674      this scope we can restore the old value of
4675      IDENTIFIER_TYPE_VALUE.  */
4676   current_binding_level->shadowed_labels
4677     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4678                  current_binding_level->shadowed_labels);
4679   /* Look for the label.  */
4680   decl = make_label_decl (id, /*local_p=*/1);
4681   /* Now fill in the information we didn't have before.  */
4682   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4683
4684   return decl;
4685 }
4686
4687 /* Define a label, specifying the location in the source file.
4688    Return the LABEL_DECL node for the label, if the definition is valid.
4689    Otherwise return 0.  */
4690
4691 tree
4692 define_label (filename, line, name)
4693      char *filename;
4694      int line;
4695      tree name;
4696 {
4697   tree decl = lookup_label (name);
4698
4699   /* After labels, make any new cleanups go into their
4700      own new (temporary) binding contour.  */
4701   current_binding_level->more_cleanups_ok = 0;
4702
4703   if (name == get_identifier ("wchar_t"))
4704     cp_pedwarn ("label named wchar_t");
4705
4706   if (DECL_INITIAL (decl) != NULL_TREE)
4707     {
4708       cp_error ("duplicate label `%D'", decl);
4709       return 0;
4710     }
4711   else
4712     {
4713       struct named_label_list *uses, *prev;
4714       int identified = 0;
4715       int saw_eh = 0;
4716
4717       /* Mark label as having been defined.  */
4718       DECL_INITIAL (decl) = error_mark_node;
4719       /* Say where in the source.  */
4720       DECL_SOURCE_FILE (decl) = filename;
4721       DECL_SOURCE_LINE (decl) = line;
4722
4723       prev = NULL;
4724       uses = named_label_uses;
4725       while (uses != NULL)
4726         if (uses->label_decl == decl)
4727           {
4728             struct binding_level *b = current_binding_level;
4729             while (b)
4730               {
4731                 tree new_decls = b->names;
4732                 tree old_decls = (b == uses->binding_level)
4733                                   ? uses->names_in_scope : NULL_TREE;
4734                 while (new_decls != old_decls)
4735                   {
4736                     if (TREE_CODE (new_decls) == VAR_DECL
4737                         /* Don't complain about crossing initialization
4738                            of internal entities.  They can't be accessed,
4739                            and they should be cleaned up
4740                            by the time we get to the label.  */
4741                         && ! DECL_ARTIFICIAL (new_decls)
4742                         && !(DECL_INITIAL (new_decls) == NULL_TREE
4743                              && pod_type_p (TREE_TYPE (new_decls))))
4744                       {
4745                         /* This is really only important if we're crossing
4746                            an initialization.  The POD stuff is just
4747                            pedantry; why should it matter if the class
4748                            contains a field of pointer to member type?  */
4749                         int problem = (DECL_INITIAL (new_decls)
4750                                        || (TYPE_NEEDS_CONSTRUCTING
4751                                            (TREE_TYPE (new_decls))));
4752
4753                         if (! identified)
4754                           {
4755                             if (problem)
4756                               {
4757                                 cp_error ("jump to label `%D'", decl);
4758                                 error_with_file_and_line
4759                                   (uses->filename_o_goto,
4760                                    uses->lineno_o_goto, "  from here");
4761                               }
4762                             else
4763                               {
4764                                 cp_pedwarn ("jump to label `%D'", decl);
4765                                 pedwarn_with_file_and_line
4766                                   (uses->filename_o_goto,
4767                                    uses->lineno_o_goto, "  from here");
4768                               }
4769                             identified = 1;
4770                           }
4771
4772                         if (problem)
4773                           cp_error_at ("  crosses initialization of `%#D'",
4774                                        new_decls);
4775                         else
4776                           cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4777                                          new_decls);
4778                       }
4779                     new_decls = TREE_CHAIN (new_decls);
4780                   }
4781                 if (b == uses->binding_level)
4782                   break;
4783                 if (b->eh_region && ! saw_eh)
4784                   {
4785                     if (! identified)
4786                       {
4787                         cp_error ("jump to label `%D'", decl);
4788                         error_with_file_and_line
4789                           (uses->filename_o_goto,
4790                            uses->lineno_o_goto, "  from here");
4791                         identified = 1;
4792                       }
4793                     error ("  enters exception handling block");
4794                     saw_eh = 1;
4795                   }
4796                 b = b->level_chain;
4797               }
4798
4799             if (prev != NULL)
4800               prev->next = uses->next;
4801             else
4802               named_label_uses = uses->next;
4803
4804             uses = uses->next;
4805           }
4806         else
4807           {
4808             prev = uses;
4809             uses = uses->next;
4810           }
4811       current_function_return_value = NULL_TREE;
4812       return decl;
4813     }
4814 }
4815
4816 struct cp_switch
4817 {
4818   struct binding_level *level;
4819   struct cp_switch *next;
4820 };
4821
4822 static struct cp_switch *switch_stack;
4823
4824 void
4825 push_switch ()
4826 {
4827   struct cp_switch *p
4828     = (struct cp_switch *) oballoc (sizeof (struct cp_switch));
4829   p->level = current_binding_level;
4830   p->next = switch_stack;
4831   switch_stack = p;
4832 }
4833
4834 void
4835 pop_switch ()
4836 {
4837   switch_stack = switch_stack->next;
4838 }
4839
4840 /* Note that we've seen a definition of a case label, and complain if this
4841    is a bad place for one.  */
4842
4843 void
4844 define_case_label ()
4845 {
4846   tree cleanup = last_cleanup_this_contour ();
4847   struct binding_level *b = current_binding_level;
4848   int identified = 0;
4849
4850   if (! switch_stack)
4851     /* Don't crash; we'll complain in do_case.  */
4852     return;
4853
4854   if (cleanup)
4855     {
4856       static int explained = 0;
4857       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4858       warning ("where case label appears here");
4859       if (!explained)
4860         {
4861           warning ("(enclose actions of previous case statements requiring");
4862           warning ("destructors in their own binding contours.)");
4863           explained = 1;
4864         }
4865     }
4866
4867   for (; b && b != switch_stack->level; b = b->level_chain)
4868     {
4869       tree new_decls = b->names;
4870       for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4871         {
4872           if (TREE_CODE (new_decls) == VAR_DECL
4873               /* Don't complain about crossing initialization
4874                  of internal entities.  They can't be accessed,
4875                  and they should be cleaned up
4876                  by the time we get to the label.  */
4877               && ! DECL_ARTIFICIAL (new_decls)
4878               && ((DECL_INITIAL (new_decls) != NULL_TREE
4879                    && DECL_INITIAL (new_decls) != error_mark_node)
4880                   || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4881             {
4882               if (! identified)
4883                 error ("jump to case label");
4884               identified = 1;
4885               cp_error_at ("  crosses initialization of `%#D'",
4886                            new_decls);
4887             }
4888         }
4889     }
4890
4891   /* After labels, make any new cleanups go into their
4892      own new (temporary) binding contour.  */
4893
4894   current_binding_level->more_cleanups_ok = 0;
4895   current_function_return_value = NULL_TREE;
4896 }
4897 \f
4898 /* Return the list of declarations of the current level.
4899    Note that this list is in reverse order unless/until
4900    you nreverse it; and when you do nreverse it, you must
4901    store the result back using `storedecls' or you will lose.  */
4902
4903 tree
4904 getdecls ()
4905 {
4906   return current_binding_level->names;
4907 }
4908
4909 /* Return the list of type-tags (for structs, etc) of the current level.  */
4910
4911 tree
4912 gettags ()
4913 {
4914   return current_binding_level->tags;
4915 }
4916
4917 /* Store the list of declarations of the current level.
4918    This is done for the parameter declarations of a function being defined,
4919    after they are modified in the light of any missing parameters.  */
4920
4921 static void
4922 storedecls (decls)
4923      tree decls;
4924 {
4925   current_binding_level->names = decls;
4926 }
4927
4928 /* Similarly, store the list of tags of the current level.  */
4929
4930 void
4931 storetags (tags)
4932      tree tags;
4933 {
4934   current_binding_level->tags = tags;
4935 }
4936 \f
4937 /* Given NAME, an IDENTIFIER_NODE,
4938    return the structure (or union or enum) definition for that name.
4939    Searches binding levels from BINDING_LEVEL up to the global level.
4940    If THISLEVEL_ONLY is nonzero, searches only the specified context
4941    (but skips any tag-transparent contexts to find one that is
4942    meaningful for tags).
4943    FORM says which kind of type the caller wants;
4944    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4945    If the wrong kind of type is found, and it's not a template, an error is
4946    reported.  */
4947
4948 static tree
4949 lookup_tag (form, name, binding_level, thislevel_only)
4950      enum tree_code form;
4951      tree name;
4952      struct binding_level *binding_level;
4953      int thislevel_only;
4954 {
4955   register struct binding_level *level;
4956   /* Non-zero if, we should look past a pseudo-global level, even if
4957      THISLEVEL_ONLY.  */
4958   int allow_pseudo_global = 1;
4959
4960   for (level = binding_level; level; level = level->level_chain)
4961     {
4962       register tree tail;
4963       if (ANON_AGGRNAME_P (name))
4964         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4965           {
4966             /* There's no need for error checking here, because
4967                anon names are unique throughout the compilation.  */
4968             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
4969               return TREE_VALUE (tail);
4970           }
4971       else if (level->namespace_p)
4972         /* Do namespace lookup. */
4973         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
4974           {
4975             tree old = binding_for_name (name, tail);
4976
4977             /* If we just skipped past a pseudo global level, even
4978                though THISLEVEL_ONLY, and we find a template class
4979                declaration, then we use the _TYPE node for the
4980                template.  See the example below.  */
4981             if (thislevel_only && !allow_pseudo_global
4982                 && old && BINDING_VALUE (old)
4983                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
4984               old = TREE_TYPE (BINDING_VALUE (old));
4985             else
4986               old = BINDING_TYPE (old);
4987
4988             /* If it has an original type, it is a typedef, and we
4989                should not return it.  */
4990             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
4991               old = NULL_TREE;
4992             if (old && TREE_CODE (old) != form
4993                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
4994               {
4995                 cp_error ("`%#D' redeclared as %C", old, form);
4996                 return NULL_TREE;
4997               }
4998             if (old)
4999               return old;
5000             if (thislevel_only || tail == global_namespace)
5001               return NULL_TREE;
5002           }
5003       else
5004         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5005           {
5006             if (TREE_PURPOSE (tail) == name)
5007               {
5008                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5009                 /* Should tighten this up; it'll probably permit
5010                    UNION_TYPE and a struct template, for example.  */
5011                 if (code != form
5012                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5013                   {
5014                     /* Definition isn't the kind we were looking for.  */
5015                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5016                               form);
5017                     return NULL_TREE;
5018                   }
5019                 return TREE_VALUE (tail);
5020               }
5021           }
5022       if (thislevel_only && ! level->tag_transparent)
5023         {
5024           if (level->pseudo_global && allow_pseudo_global)
5025             {
5026               /* We must deal with cases like this:
5027
5028                    template <class T> struct S;
5029                    template <class T> struct S {};
5030
5031                  When looking up `S', for the second declaration, we
5032                  would like to find the first declaration.  But, we
5033                  are in the pseudo-global level created for the
5034                  template parameters, rather than the (surrounding)
5035                  namespace level.  Thus, we keep going one more level,
5036                  even though THISLEVEL_ONLY is non-zero.  */
5037               allow_pseudo_global = 0;
5038               continue;
5039             }
5040           else
5041             return NULL_TREE;
5042         }
5043     }
5044   return NULL_TREE;
5045 }
5046
5047 #if 0
5048 void
5049 set_current_level_tags_transparency (tags_transparent)
5050      int tags_transparent;
5051 {
5052   current_binding_level->tag_transparent = tags_transparent;
5053 }
5054 #endif
5055
5056 /* Given a type, find the tag that was defined for it and return the tag name.
5057    Otherwise return 0.  However, the value can never be 0
5058    in the cases in which this is used.
5059
5060    C++: If NAME is non-zero, this is the new name to install.  This is
5061    done when replacing anonymous tags with real tag names.  */
5062
5063 static tree
5064 lookup_tag_reverse (type, name)
5065      tree type;
5066      tree name;
5067 {
5068   register struct binding_level *level;
5069
5070   for (level = current_binding_level; level; level = level->level_chain)
5071     {
5072       register tree tail;
5073       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5074         {
5075           if (TREE_VALUE (tail) == type)
5076             {
5077               if (name)
5078                 TREE_PURPOSE (tail) = name;
5079               return TREE_PURPOSE (tail);
5080             }
5081         }
5082     }
5083   return NULL_TREE;
5084 }
5085 \f
5086 /* Look up NAME in the NAMESPACE.  */
5087
5088 tree
5089 lookup_namespace_name (namespace, name)
5090      tree namespace, name;
5091 {
5092   tree val;
5093   tree template_id = NULL_TREE;
5094
5095   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5096
5097   if (TREE_CODE (name) == NAMESPACE_DECL)
5098     /* This happens for A::B<int> when B is a namespace. */
5099     return name;
5100   else if (TREE_CODE (name) == TEMPLATE_DECL)
5101     {
5102       /* This happens for A::B where B is a template, and there are no
5103          template arguments.  */
5104       cp_error ("invalid use of `%D'", name);
5105       return error_mark_node;
5106     }
5107
5108   namespace = ORIGINAL_NAMESPACE (namespace);
5109
5110   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5111     {
5112       template_id = name;
5113       name = TREE_OPERAND (name, 0);
5114       if (TREE_CODE (name) == OVERLOAD)
5115         name = DECL_NAME (OVL_CURRENT (name));
5116       else if (TREE_CODE_CLASS (TREE_CODE (name)) == 'd')
5117         name = DECL_NAME (name);
5118     }
5119
5120   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5121
5122   val = make_node (CPLUS_BINDING);
5123   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5124     return error_mark_node;
5125
5126   if (BINDING_VALUE (val))
5127     {
5128       val = BINDING_VALUE (val);
5129
5130       if (template_id)
5131         {
5132           if (DECL_CLASS_TEMPLATE_P (val))
5133             val = lookup_template_class (val,
5134                                          TREE_OPERAND (template_id, 1),
5135                                          /*in_decl=*/NULL_TREE,
5136                                          /*context=*/NULL_TREE,
5137                                          /*entering_scope=*/0);
5138           else if (DECL_FUNCTION_TEMPLATE_P (val)
5139                    || TREE_CODE (val) == OVERLOAD)
5140             val = lookup_template_function (val,
5141                                             TREE_OPERAND (template_id, 1));
5142           else
5143             {
5144               cp_error ("`%D::%D' is not a template",
5145                         namespace, name);
5146               return error_mark_node;
5147             }
5148         }
5149
5150       /* If we have a single function from a using decl, pull it out.  */
5151       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5152         val = OVL_FUNCTION (val);
5153       return val;
5154     }
5155
5156   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5157   return error_mark_node;
5158 }
5159
5160 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5161
5162 static unsigned long
5163 typename_hash (k)
5164      hash_table_key k;
5165 {
5166   unsigned long hash;
5167   tree t;
5168
5169   t = (tree) k;
5170   hash = (((unsigned long) TYPE_CONTEXT (t))
5171           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5172
5173   return hash;
5174 }
5175
5176 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5177
5178 static boolean
5179 typename_compare (k1, k2)
5180      hash_table_key k1;
5181      hash_table_key k2;
5182 {
5183   tree t1;
5184   tree t2;
5185   tree d1;
5186   tree d2;
5187
5188   t1 = (tree) k1;
5189   t2 = (tree) k2;
5190   d1 = TYPE_NAME (t1);
5191   d2 = TYPE_NAME (t2);
5192
5193   return (DECL_NAME (d1) == DECL_NAME (d2)
5194           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5195           && ((TREE_TYPE (t1) != NULL_TREE)
5196               == (TREE_TYPE (t2) != NULL_TREE))
5197           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5198           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5199 }
5200
5201 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5202    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5203    is non-NULL, this type is being created by the implicit typename
5204    extension, and BASE_TYPE is a type named `t' in some base class of
5205    `T' which depends on template parameters.
5206
5207    Returns the new TYPENAME_TYPE.  */
5208
5209 tree
5210 build_typename_type (context, name, fullname, base_type)
5211      tree context;
5212      tree name;
5213      tree fullname;
5214      tree base_type;
5215 {
5216   tree t;
5217   tree d;
5218   struct hash_entry* e;
5219
5220   static struct hash_table ht;
5221
5222   if (!ht.table)
5223     {
5224       static struct hash_table *h = &ht;
5225       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5226                             &typename_compare))
5227         fatal ("virtual memory exhausted");
5228       ggc_add_tree_hash_table_root (&h, 1);
5229     }
5230
5231   /* Build the TYPENAME_TYPE.  */
5232   t = make_aggr_type (TYPENAME_TYPE);
5233   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5234   TYPENAME_TYPE_FULLNAME (t) = fullname;
5235   TREE_TYPE (t) = base_type;
5236
5237   /* Build the corresponding TYPE_DECL.  */
5238   d = build_decl (TYPE_DECL, name, t);
5239   TYPE_NAME (TREE_TYPE (d)) = d;
5240   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5241   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5242   DECL_ARTIFICIAL (d) = 1;
5243
5244   /* See if we already have this type.  */
5245   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5246   if (e)
5247     t = (tree) e->key;
5248   else
5249     /* Insert the type into the table.  */
5250     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5251
5252   return t;
5253 }
5254
5255 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5256    unless an error occurs, in which case error_mark_node is returned.
5257    If COMPLAIN zero, don't complain about any errors that occur.  */
5258
5259 tree
5260 make_typename_type (context, name, complain)
5261      tree context, name;
5262      int complain;
5263 {
5264   tree fullname;
5265
5266   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
5267     {
5268       if (!(TYPE_LANG_SPECIFIC (name)
5269             && (CLASSTYPE_IS_TEMPLATE (name)
5270                 || CLASSTYPE_USE_TEMPLATE (name))))
5271         name = TYPE_IDENTIFIER (name);
5272       else
5273         /* Create a TEMPLATE_ID_EXPR for the type.  */
5274         name = build_nt (TEMPLATE_ID_EXPR,
5275                          CLASSTYPE_TI_TEMPLATE (name),
5276                          CLASSTYPE_TI_ARGS (name));
5277     }
5278   else if (TREE_CODE (name) == TYPE_DECL)
5279     name = DECL_NAME (name);
5280
5281   fullname = name;
5282
5283   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5284     {
5285       name = TREE_OPERAND (name, 0);
5286       if (TREE_CODE (name) == TEMPLATE_DECL)
5287         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5288     }
5289   if (TREE_CODE (name) != IDENTIFIER_NODE)
5290     my_friendly_abort (2000);
5291
5292   if (TREE_CODE (context) == NAMESPACE_DECL)
5293     {
5294       /* We can get here from typename_sub0 in the explicit_template_type
5295          expansion.  Just fail.  */
5296       if (complain)
5297         cp_error ("no class template named `%#T' in `%#T'",
5298                   name, context);
5299       return error_mark_node;
5300     }
5301
5302   if (! uses_template_parms (context)
5303       || currently_open_class (context))
5304     {
5305       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5306         {
5307           tree tmpl = NULL_TREE;
5308           if (IS_AGGR_TYPE (context))
5309             tmpl = lookup_field (context, name, 0, 0);
5310           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5311             {
5312               if (complain)
5313                 cp_error ("no class template named `%#T' in `%#T'",
5314                           name, context);
5315               return error_mark_node;
5316             }
5317
5318           return lookup_template_class (tmpl,
5319                                         TREE_OPERAND (fullname, 1),
5320                                         NULL_TREE, context,
5321                                         /*entering_scope=*/0);
5322         }
5323       else
5324         {
5325           tree t;
5326
5327           if (!IS_AGGR_TYPE (context))
5328             {
5329               if (complain)
5330                 cp_error ("no type named `%#T' in `%#T'", name, context);
5331               return error_mark_node;
5332             }
5333
5334           t = lookup_field (context, name, 0, 1);
5335           if (t)
5336             return TREE_TYPE (t);
5337         }
5338     }
5339
5340   /* If the CONTEXT is not a template type, then either the field is
5341      there now or its never going to be.  */
5342   if (!uses_template_parms (context))
5343     {
5344       if (complain)
5345         cp_error ("no type named `%#T' in `%#T'", name, context);
5346       return error_mark_node;
5347     }
5348
5349
5350   return build_typename_type (context, name, fullname,  NULL_TREE);
5351 }
5352
5353 /* Select the right _DECL from multiple choices. */
5354
5355 static tree
5356 select_decl (binding, flags)
5357      tree binding;
5358      int flags;
5359 {
5360   tree val;
5361   val = BINDING_VALUE (binding);
5362   if (LOOKUP_NAMESPACES_ONLY (flags))
5363     {
5364       /* We are not interested in types. */
5365       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5366         return val;
5367       return NULL_TREE;
5368     }
5369
5370   /* If we could have a type and
5371      we have nothing or we need a type and have none.  */
5372   if (BINDING_TYPE (binding)
5373       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5374                    && TREE_CODE (val) != TYPE_DECL)))
5375     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5376   /* Don't return non-types if we really prefer types. */
5377   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5378            && (TREE_CODE (val) != TEMPLATE_DECL
5379                || !DECL_CLASS_TEMPLATE_P (val)))
5380     val = NULL_TREE;
5381
5382   return val;
5383 }
5384
5385 /* Unscoped lookup of a global: iterate over current namespaces,
5386    considering using-directives.  If SPACESP is non-NULL, store a list
5387    of the namespaces we've considered in it.  */
5388
5389 tree
5390 unqualified_namespace_lookup (name, flags, spacesp)
5391      tree name;
5392      int flags;
5393      tree *spacesp;
5394 {
5395   tree b = make_node (CPLUS_BINDING);
5396   tree initial = current_decl_namespace();
5397   tree scope = initial;
5398   tree siter;
5399   struct binding_level *level;
5400   tree val = NULL_TREE;
5401
5402   if (spacesp)
5403     *spacesp = NULL_TREE;
5404
5405   for (; !val; scope = CP_DECL_CONTEXT (scope))
5406     {
5407       if (spacesp)
5408         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5409       val = binding_for_name (name, scope);
5410
5411       /* Initialize binding for this context. */
5412       BINDING_VALUE (b) = BINDING_VALUE (val);
5413       BINDING_TYPE (b) = BINDING_TYPE (val);
5414
5415       /* Add all _DECLs seen through local using-directives. */
5416       for (level = current_binding_level;
5417            !level->namespace_p;
5418            level = level->level_chain)
5419         if (!lookup_using_namespace (name, b, level->using_directives,
5420                                      scope, flags, spacesp))
5421           /* Give up because of error. */
5422           return error_mark_node;
5423
5424       /* Add all _DECLs seen through global using-directives. */
5425       /* XXX local and global using lists should work equally. */
5426       siter = initial;
5427       while (1)
5428         {
5429           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5430                                        scope, flags, spacesp))
5431             /* Give up because of error. */
5432             return error_mark_node;
5433           if (siter == scope) break;
5434           siter = CP_DECL_CONTEXT (siter);
5435         }
5436
5437       val = select_decl (b, flags);
5438       if (scope == global_namespace)
5439         break;
5440     }
5441   return val;
5442 }
5443
5444 /* Combine prefer_type and namespaces_only into flags.  */
5445
5446 static int
5447 lookup_flags (prefer_type, namespaces_only)
5448   int prefer_type, namespaces_only;
5449 {
5450   if (namespaces_only)
5451     return LOOKUP_PREFER_NAMESPACES;
5452   if (prefer_type > 1)
5453     return LOOKUP_PREFER_TYPES;
5454   if (prefer_type > 0)
5455     return LOOKUP_PREFER_BOTH;
5456   return 0;
5457 }
5458
5459 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5460    ignore it or not.  Subroutine of lookup_name_real.  */
5461
5462 static tree
5463 qualify_lookup (val, flags)
5464      tree val;
5465      int flags;
5466 {
5467   if (val == NULL_TREE)
5468     return val;
5469   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5470     return val;
5471   if ((flags & LOOKUP_PREFER_TYPES)
5472       && (TREE_CODE (val) == TYPE_DECL
5473           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5474               && DECL_CLASS_TEMPLATE_P (val))))
5475     return val;
5476   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5477     return NULL_TREE;
5478   return val;
5479 }
5480
5481 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5482    that.  */
5483
5484 static void
5485 warn_about_implicit_typename_lookup (typename, binding)
5486      tree typename;
5487      tree binding;
5488 {
5489   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5490   tree name = DECL_NAME (typename);
5491
5492   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5493          && CLASSTYPE_TEMPLATE_INFO (subtype)
5494          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5495       && ! (TREE_CODE (binding) == TYPE_DECL
5496             && same_type_p (TREE_TYPE (binding), subtype)))
5497     {
5498       cp_warning ("lookup of `%D' finds `%#D'",
5499                   name, binding);
5500       cp_warning ("  instead of `%D' from dependent base class",
5501                   typename);
5502       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5503                   constructor_name (current_class_type), name);
5504     }
5505 }
5506
5507 /* Look up NAME in the current binding level and its superiors in the
5508    namespace of variables, functions and typedefs.  Return a ..._DECL
5509    node of some kind representing its definition if there is only one
5510    such declaration, or return a TREE_LIST with all the overloaded
5511    definitions if there are many, or return 0 if it is undefined.
5512
5513    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5514    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5515    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5516    Otherwise we prefer non-TYPE_DECLs.
5517
5518    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5519    using IDENTIFIER_CLASS_VALUE.  */
5520
5521 static tree
5522 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5523      tree name;
5524      int prefer_type, nonclass, namespaces_only;
5525 {
5526   tree t;
5527   tree val = NULL_TREE;
5528   int yylex = 0;
5529   tree from_obj = NULL_TREE;
5530   int flags;
5531   int val_is_implicit_typename = 0;
5532
5533   /* Hack: copy flag set by parser, if set. */
5534   if (only_namespace_names)
5535     namespaces_only = 1;
5536
5537   if (prefer_type == -2)
5538     {
5539       extern int looking_for_typename;
5540       tree type = NULL_TREE;
5541
5542       yylex = 1;
5543       prefer_type = looking_for_typename;
5544
5545       flags = lookup_flags (prefer_type, namespaces_only);
5546       /* If the next thing is '<', class templates are types. */
5547       if (looking_for_template)
5548         flags |= LOOKUP_TEMPLATES_EXPECTED;
5549
5550       /* std:: becomes :: for now.  */
5551       if (got_scope == std_node)
5552         got_scope = void_type_node;
5553
5554       if (got_scope)
5555         type = got_scope;
5556       else if (got_object != error_mark_node)
5557         type = got_object;
5558
5559       if (type)
5560         {
5561           if (type == error_mark_node)
5562             return error_mark_node;
5563           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5564             type = TREE_TYPE (type);
5565
5566           if (TYPE_P (type))
5567             type = complete_type (type);
5568
5569           if (TREE_CODE (type) == VOID_TYPE)
5570             type = global_namespace;
5571           if (TREE_CODE (type) == NAMESPACE_DECL)
5572             {
5573               val = make_node (CPLUS_BINDING);
5574               flags |= LOOKUP_COMPLAIN;
5575               if (!qualified_lookup_using_namespace (name, type, val, flags))
5576                 return NULL_TREE;
5577               val = select_decl (val, flags);
5578             }
5579           else if (! IS_AGGR_TYPE (type)
5580                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5581                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5582                    || TREE_CODE (type) == TYPENAME_TYPE)
5583             /* Someone else will give an error about this if needed.  */
5584             val = NULL_TREE;
5585           else if (type == current_class_type)
5586             val = IDENTIFIER_CLASS_VALUE (name);
5587           else
5588             val = lookup_member (type, name, 0, prefer_type);
5589         }
5590       else
5591         val = NULL_TREE;
5592
5593       if (got_scope)
5594         goto done;
5595       else if (got_object && val)
5596         from_obj = val;
5597     }
5598   else
5599     {
5600       flags = lookup_flags (prefer_type, namespaces_only);
5601       /* If we're not parsing, we need to complain. */
5602       flags |= LOOKUP_COMPLAIN;
5603     }
5604
5605   /* First, look in non-namespace scopes.  */
5606
5607   if (current_class_type == NULL_TREE)
5608     nonclass = 1;
5609
5610   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5611     {
5612       tree binding;
5613
5614       if (!LOCAL_BINDING_P (t) && nonclass)
5615         /* We're not looking for class-scoped bindings, so keep going.  */
5616         continue;
5617
5618       /* If this is the kind of thing we're looking for, we're done.  */
5619       if (qualify_lookup (BINDING_VALUE (t), flags))
5620         binding = BINDING_VALUE (t);
5621       else if ((flags & LOOKUP_PREFER_TYPES)
5622                && qualify_lookup (BINDING_TYPE (t), flags))
5623         binding = BINDING_TYPE (t);
5624       else
5625         binding = NULL_TREE;
5626
5627       if (binding
5628           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5629         {
5630           if (val_is_implicit_typename && !yylex)
5631             warn_about_implicit_typename_lookup (val, binding);
5632           val = binding;
5633           val_is_implicit_typename
5634             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5635           if (!val_is_implicit_typename)
5636             break;
5637         }
5638     }
5639
5640   /* Now lookup in namespace scopes.  */
5641   if (!val || val_is_implicit_typename)
5642     {
5643       t = unqualified_namespace_lookup (name, flags, 0);
5644       if (t)
5645         {
5646           if (val_is_implicit_typename && !yylex)
5647             warn_about_implicit_typename_lookup (val, t);
5648           val = t;
5649         }
5650     }
5651
5652  done:
5653   if (val)
5654     {
5655       /* This should only warn about types used in qualified-ids.  */
5656       if (from_obj && from_obj != val)
5657         {
5658           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5659               && TREE_CODE (val) == TYPE_DECL
5660               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5661             {
5662               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5663                           name, got_object, TREE_TYPE (from_obj));
5664               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5665                           TREE_TYPE (val));
5666             }
5667
5668           /* We don't change val to from_obj if got_object depends on
5669              template parms because that breaks implicit typename for
5670              destructor calls.  */
5671           if (! uses_template_parms (got_object))
5672             val = from_obj;
5673         }
5674
5675       /* If we have a single function from a using decl, pull it out.  */
5676       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5677         val = OVL_FUNCTION (val);
5678     }
5679   else if (from_obj)
5680     val = from_obj;
5681
5682   return val;
5683 }
5684
5685 tree
5686 lookup_name_nonclass (name)
5687      tree name;
5688 {
5689   return lookup_name_real (name, 0, 1, 0);
5690 }
5691
5692 tree
5693 lookup_function_nonclass (name, args)
5694      tree name;
5695      tree args;
5696 {
5697   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5698 }
5699
5700 tree
5701 lookup_name_namespace_only (name)
5702      tree name;
5703 {
5704   /* type-or-namespace, nonclass, namespace_only */
5705   return lookup_name_real (name, 1, 1, 1);
5706 }
5707
5708 tree
5709 lookup_name (name, prefer_type)
5710      tree name;
5711      int prefer_type;
5712 {
5713   return lookup_name_real (name, prefer_type, 0, 0);
5714 }
5715
5716 /* Similar to `lookup_name' but look only in the innermost non-class
5717    binding level.  */
5718
5719 tree
5720 lookup_name_current_level (name)
5721      tree name;
5722 {
5723   struct binding_level *b;
5724   tree t = NULL_TREE;
5725
5726   b = current_binding_level;
5727   while (b->parm_flag == 2)
5728     b = b->level_chain;
5729
5730   if (b->namespace_p)
5731     {
5732       t = IDENTIFIER_NAMESPACE_VALUE (name);
5733
5734       /* extern "C" function() */
5735       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5736         t = TREE_VALUE (t);
5737     }
5738   else if (IDENTIFIER_BINDING (name)
5739            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
5740     {
5741       while (1)
5742         {
5743           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
5744             return IDENTIFIER_VALUE (name);
5745
5746           if (b->keep == 2)
5747             b = b->level_chain;
5748           else
5749             break;
5750         }
5751     }
5752
5753   return t;
5754 }
5755
5756 /* Like lookup_name_current_level, but for types.  */
5757
5758 tree
5759 lookup_type_current_level (name)
5760      tree name;
5761 {
5762   register tree t = NULL_TREE;
5763
5764   my_friendly_assert (! current_binding_level->namespace_p, 980716);
5765
5766   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5767       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5768     {
5769       struct binding_level *b = current_binding_level;
5770       while (1)
5771         {
5772           if (purpose_member (name, b->type_shadowed))
5773             return REAL_IDENTIFIER_TYPE_VALUE (name);
5774           if (b->keep == 2)
5775             b = b->level_chain;
5776           else
5777             break;
5778         }
5779     }
5780
5781   return t;
5782 }
5783
5784 void
5785 begin_only_namespace_names ()
5786 {
5787   only_namespace_names = 1;
5788 }
5789
5790 void
5791 end_only_namespace_names ()
5792 {
5793   only_namespace_names = 0;
5794 }
5795 \f
5796 /* Arrange for the user to get a source line number, even when the
5797    compiler is going down in flames, so that she at least has a
5798    chance of working around problems in the compiler.  We used to
5799    call error(), but that let the segmentation fault continue
5800    through; now, it's much more passive by asking them to send the
5801    maintainers mail about the problem.  */
5802
5803 static void
5804 signal_catch (sig)
5805      int sig ATTRIBUTE_UNUSED;
5806 {
5807   signal (SIGSEGV, SIG_DFL);
5808 #ifdef SIGIOT
5809   signal (SIGIOT, SIG_DFL);
5810 #endif
5811 #ifdef SIGILL
5812   signal (SIGILL, SIG_DFL);
5813 #endif
5814 #ifdef SIGABRT
5815   signal (SIGABRT, SIG_DFL);
5816 #endif
5817 #ifdef SIGBUS
5818   signal (SIGBUS, SIG_DFL);
5819 #endif
5820   my_friendly_abort (0);
5821 }
5822
5823 /* Push the declarations of builtin types into the namespace.
5824    RID_INDEX, if < RID_MAX is the index of the builtin type
5825    in the array RID_POINTERS.  NAME is the name used when looking
5826    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
5827
5828 static void
5829 record_builtin_type (rid_index, name, type)
5830      enum rid rid_index;
5831      const char *name;
5832      tree type;
5833 {
5834   tree rname = NULL_TREE, tname = NULL_TREE;
5835   tree tdecl = NULL_TREE;
5836
5837   if ((int) rid_index < (int) RID_MAX)
5838     rname = ridpointers[(int) rid_index];
5839   if (name)
5840     tname = get_identifier (name);
5841
5842   TYPE_BUILT_IN (type) = 1;
5843
5844   if (tname)
5845     {
5846       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5847       set_identifier_type_value (tname, NULL_TREE);
5848       if ((int) rid_index < (int) RID_MAX)
5849         /* Built-in types live in the global namespace. */
5850         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5851     }
5852   if (rname != NULL_TREE)
5853     {
5854       if (tname != NULL_TREE)
5855         {
5856           set_identifier_type_value (rname, NULL_TREE);
5857           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5858         }
5859       else
5860         {
5861           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5862           set_identifier_type_value (rname, NULL_TREE);
5863         }
5864     }
5865 }
5866
5867 /* Record one of the standard Java types.
5868  * Declare it as having the given NAME.
5869  * If SIZE > 0, it is the size of one of the integral types;
5870  * otherwise it is the negative of the size of one of the other types.  */
5871
5872 static tree
5873 record_builtin_java_type (name, size)
5874      const char *name;
5875      int size;
5876 {
5877   tree type, decl;
5878   if (size > 0)
5879     type = make_signed_type (size);
5880   else if (size > -32)
5881     { /* "__java_char" or ""__java_boolean". */
5882       type = make_unsigned_type (-size);
5883       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5884     }
5885   else
5886     { /* "__java_float" or ""__java_double". */
5887       type = make_node (REAL_TYPE);
5888       TYPE_PRECISION (type) = - size;
5889       layout_type (type);
5890     }
5891   record_builtin_type (RID_MAX, name, type);
5892   decl = TYPE_NAME (type);
5893
5894   /* Suppress generate debug symbol entries for these types,
5895      since for normal C++ they are just clutter.
5896      However, push_lang_context undoes this if extern "Java" is seen. */
5897   DECL_IGNORED_P (decl) = 1;
5898
5899   TYPE_FOR_JAVA (type) = 1;
5900   return type;
5901 }
5902
5903 /* Push a type into the namespace so that the back-ends ignore it. */
5904
5905 static void
5906 record_unknown_type (type, name)
5907      tree type;
5908      const char *name;
5909 {
5910   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
5911   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
5912   DECL_IGNORED_P (decl) = 1;
5913   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5914   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
5915   TYPE_ALIGN (type) = 1;
5916   TYPE_MODE (type) = TYPE_MODE (void_type_node);
5917 }
5918
5919 /* Push overloaded decl, in global scope, with one argument so it
5920    can be used as a callback from define_function.  */
5921
5922 static void
5923 push_overloaded_decl_1 (x)
5924      tree x;
5925 {
5926   pushdecl (x);
5927 }
5928
5929 inline tree
5930 auto_function (name, type)
5931      tree name, type;
5932 {
5933   return define_function
5934     (IDENTIFIER_POINTER (name), type, push_overloaded_decl_1,
5935      IDENTIFIER_POINTER (build_decl_overload (name, TYPE_ARG_TYPES (type),
5936                                               0)));
5937 }
5938
5939 /* Create the predefined scalar types of C,
5940    and some nodes representing standard constants (0, 1, (void *)0).
5941    Initialize the global binding level.
5942    Make definitions for built-in primitive functions.  */
5943
5944 void
5945 init_decl_processing ()
5946 {
5947   tree fields[20];
5948   int wchar_type_size;
5949   tree array_domain_type;
5950
5951   /* Have to make these distinct before we try using them.  */
5952   lang_name_cplusplus = get_identifier ("C++");
5953   lang_name_c = get_identifier ("C");
5954   lang_name_java = get_identifier ("Java");
5955
5956   /* Let the back-end now how to save and restore language-specific
5957      per-function globals.  */
5958   init_lang_status = &push_cp_function_context;
5959   free_lang_status = &pop_cp_function_context;
5960   mark_lang_status = &mark_cp_function_context;
5961
5962   cp_parse_init ();
5963   init_decl2 ();
5964   init_pt ();
5965
5966   /* Create the global variables.  */
5967   push_to_top_level ();
5968
5969   /* Enter the global namespace. */
5970   my_friendly_assert (global_namespace == NULL_TREE, 375);
5971   push_namespace (get_identifier ("::"));
5972   global_namespace = current_namespace;
5973   current_lang_name = NULL_TREE;
5974
5975   /* Adjust various flags based on command-line settings.  */
5976   if (flag_strict_prototype == 2)
5977     flag_strict_prototype = pedantic;
5978   if (! flag_permissive && ! pedantic)
5979     flag_pedantic_errors = 1;
5980   if (!flag_no_inline)
5981     flag_inline_trees = 1;
5982
5983   strict_prototypes_lang_c = flag_strict_prototype;
5984
5985   /* Initially, C.  */
5986   current_lang_name = lang_name_c;
5987
5988   current_function_decl = NULL_TREE;
5989   current_binding_level = NULL_BINDING_LEVEL;
5990   free_binding_level = NULL_BINDING_LEVEL;
5991
5992   /* Because most segmentation signals can be traced back into user
5993      code, catch them and at least give the user a chance of working
5994      around compiler bugs.  */
5995   signal (SIGSEGV, signal_catch);
5996
5997   /* We will also catch aborts in the back-end through signal_catch and
5998      give the user a chance to see where the error might be, and to defeat
5999      aborts in the back-end when there have been errors previously in their
6000      code.  */
6001 #ifdef SIGIOT
6002   signal (SIGIOT, signal_catch);
6003 #endif
6004 #ifdef SIGILL
6005   signal (SIGILL, signal_catch);
6006 #endif
6007 #ifdef SIGABRT
6008   signal (SIGABRT, signal_catch);
6009 #endif
6010 #ifdef SIGBUS
6011   signal (SIGBUS, signal_catch);
6012 #endif
6013
6014   build_common_tree_nodes (flag_signed_char);
6015
6016   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6017   TREE_TYPE (error_mark_list) = error_mark_node;
6018
6019   /* Make the binding_level structure for global names.  */
6020   pushlevel (0);
6021   global_binding_level = current_binding_level;
6022   /* The global level is the namespace level of ::.  */
6023   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6024   declare_namespace_level ();
6025
6026   this_identifier = get_identifier (THIS_NAME);
6027   in_charge_identifier = get_identifier (IN_CHARGE_NAME);
6028   ctor_identifier = get_identifier (CTOR_NAME);
6029   dtor_identifier = get_identifier (DTOR_NAME);
6030   pfn_identifier = get_identifier (VTABLE_PFN_NAME);
6031   index_identifier = get_identifier (VTABLE_INDEX_NAME);
6032   delta_identifier = get_identifier (VTABLE_DELTA_NAME);
6033   delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
6034   pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
6035
6036   /* Define `int' and `char' first so that dbx will output them first.  */
6037   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6038   record_builtin_type (RID_CHAR, "char", char_type_node);
6039
6040   /* `signed' is the same as `int' */
6041   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6042   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6043   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6044   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6045   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6046   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6047   record_builtin_type (RID_MAX, "long long unsigned int",
6048                        long_long_unsigned_type_node);
6049   record_builtin_type (RID_MAX, "long long unsigned",
6050                        long_long_unsigned_type_node);
6051   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6052   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6053   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6054
6055   ptrdiff_type_node
6056     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6057
6058   /* Define both `signed char' and `unsigned char'.  */
6059   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6060   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6061
6062   /* `unsigned long' is the standard type for sizeof.
6063      Note that stddef.h uses `unsigned long',
6064      and this must agree, even if long and int are the same size.  */
6065   set_sizetype
6066     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6067
6068   /* Create the widest literal types. */
6069   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6070   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6071                         widest_integer_literal_type_node));
6072
6073   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6074   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6075                         widest_unsigned_literal_type_node));
6076
6077   /* These are types that type_for_size and type_for_mode use.  */
6078   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6079   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6080   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6081   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6082 #if HOST_BITS_PER_WIDE_INT >= 64
6083   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6084 #endif
6085   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6086   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6087   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6088   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6089 #if HOST_BITS_PER_WIDE_INT >= 64
6090   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6091 #endif
6092
6093   build_common_tree_nodes_2 (flag_short_double);
6094
6095   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6096   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6097   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6098   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6099   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6100   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6101   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6102   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6103
6104   integer_two_node = build_int_2 (2, 0);
6105   TREE_TYPE (integer_two_node) = integer_type_node;
6106   integer_three_node = build_int_2 (3, 0);
6107   TREE_TYPE (integer_three_node) = integer_type_node;
6108
6109   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6110   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6111   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6112   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6113   TYPE_PRECISION (boolean_type_node) = 1;
6114   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6115   boolean_false_node = build_int_2 (0, 0);
6116   TREE_TYPE (boolean_false_node) = boolean_type_node;
6117   boolean_true_node = build_int_2 (1, 0);
6118   TREE_TYPE (boolean_true_node) = boolean_type_node;
6119
6120   signed_size_zero_node = build_int_2 (0, 0);  record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6121   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6122   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6123
6124   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6125                         complex_integer_type_node));
6126   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6127                         complex_float_type_node));
6128   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6129                         complex_double_type_node));
6130   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6131                         complex_long_double_type_node));
6132
6133   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6134
6135   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6136   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6137   TREE_PARMLIST (void_list_node) = 1;
6138
6139   /* Used for expressions that do nothing, but are not errors.  */
6140   void_zero_node = build_int_2 (0, 0);
6141   TREE_TYPE (void_zero_node) = void_type_node;
6142
6143   string_type_node = build_pointer_type (char_type_node);
6144   const_string_type_node
6145     = build_pointer_type (build_qualified_type (char_type_node,
6146                                                 TYPE_QUAL_CONST));
6147   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6148 #if 0
6149   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6150 #endif
6151
6152   /* Make a type to be the domain of a few array types
6153      whose domains don't really matter.
6154      200 is small enough that it always fits in size_t
6155      and large enough that it can hold most function names for the
6156      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
6157   array_domain_type = build_index_type (build_int_2 (200, 0));
6158
6159   /* Make a type for arrays of characters.
6160      With luck nothing will ever really depend on the length of this
6161      array type.  */
6162   char_array_type_node
6163     = build_array_type (char_type_node, array_domain_type);
6164   /* Likewise for arrays of ints.  */
6165   int_array_type_node
6166     = build_array_type (integer_type_node, array_domain_type);
6167
6168   /* This is just some anonymous class type.  Nobody should ever
6169      need to look inside this envelope.  */
6170   class_star_type_node = build_pointer_type (make_aggr_type (RECORD_TYPE));
6171
6172   if (flag_huge_objects)
6173     delta_type_node = long_integer_type_node;
6174   else
6175     delta_type_node = short_integer_type_node;
6176
6177   default_function_type
6178     = build_function_type (integer_type_node, NULL_TREE);
6179
6180   ptr_type_node = build_pointer_type (void_type_node);
6181   const_ptr_type_node
6182     = build_pointer_type (build_qualified_type (void_type_node,
6183                                                 TYPE_QUAL_CONST));
6184   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6185   lang_type_promotes_to = convert_type_from_ellipsis;
6186
6187   void_ftype_ptr
6188     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6189
6190   /* C++ extensions */
6191
6192   unknown_type_node = make_node (UNKNOWN_TYPE);
6193   record_unknown_type (unknown_type_node, "unknown type");
6194
6195   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6196   TREE_TYPE (unknown_type_node) = unknown_type_node;
6197
6198   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6199
6200   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6201      result.  */
6202   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6203   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6204
6205   /* This is special for C++ so functions can be overloaded.  */
6206   wchar_type_node = get_identifier (flag_short_wchar
6207                                     ? "short unsigned int"
6208                                     : WCHAR_TYPE);
6209   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6210   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6211   signed_wchar_type_node = make_signed_type (wchar_type_size);
6212   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6213   wchar_type_node
6214     = TREE_UNSIGNED (wchar_type_node)
6215       ? unsigned_wchar_type_node
6216       : signed_wchar_type_node;
6217   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6218
6219   /* Artificial declaration of wchar_t -- can be bashed */
6220   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6221                                 wchar_type_node);
6222   pushdecl (wchar_decl_node);
6223
6224   /* This is for wide string constants.  */
6225   wchar_array_type_node
6226     = build_array_type (wchar_type_node, array_domain_type);
6227
6228   if (flag_vtable_thunks)
6229     {
6230       /* Make sure we get a unique function type, so we can give
6231          its pointer type a name.  (This wins for gdb.) */
6232       tree vfunc_type = make_node (FUNCTION_TYPE);
6233       TREE_TYPE (vfunc_type) = integer_type_node;
6234       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6235       layout_type (vfunc_type);
6236
6237       vtable_entry_type = build_pointer_type (vfunc_type);
6238     }
6239   else
6240     {
6241       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6242       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
6243                                    delta_type_node);
6244       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
6245                                    delta_type_node);
6246       fields[2] = build_lang_decl (FIELD_DECL, pfn_identifier,
6247                                    ptr_type_node);
6248       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6249                            double_type_node);
6250
6251       /* Make this part of an invisible union.  */
6252       fields[3] = copy_node (fields[2]);
6253       TREE_TYPE (fields[3]) = delta_type_node;
6254       DECL_NAME (fields[3]) = delta2_identifier;
6255       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6256       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6257       TREE_UNSIGNED (fields[3]) = 0;
6258       TREE_CHAIN (fields[2]) = fields[3];
6259       vtable_entry_type = build_qualified_type (vtable_entry_type,
6260                                                 TYPE_QUAL_CONST);
6261     }
6262   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6263
6264   vtbl_type_node
6265     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6266   layout_type (vtbl_type_node);
6267   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6268   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6269   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6270   layout_type (vtbl_ptr_type_node);
6271   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6272
6273   std_node = build_decl (NAMESPACE_DECL,
6274                          get_identifier (flag_honor_std ? "fake std":"std"),
6275                          void_type_node);
6276   pushdecl (std_node);
6277
6278   global_type_node = make_node (LANG_TYPE);
6279   record_unknown_type (global_type_node, "global type");
6280
6281   /* Now, C++.  */
6282   current_lang_name = lang_name_cplusplus;
6283
6284   {
6285     tree bad_alloc_type_node, newtype, deltype;
6286     if (flag_honor_std)
6287       push_namespace (get_identifier ("std"));
6288     bad_alloc_type_node = xref_tag
6289       (class_type_node, get_identifier ("bad_alloc"), 1);
6290     if (flag_honor_std)
6291       pop_namespace ();
6292     newtype = build_exception_variant
6293       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6294     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6295     auto_function (ansi_opname[(int) NEW_EXPR], newtype);
6296     auto_function (ansi_opname[(int) VEC_NEW_EXPR], newtype);
6297     global_delete_fndecl = auto_function (ansi_opname[(int) DELETE_EXPR],
6298                                           deltype);
6299     auto_function (ansi_opname[(int) VEC_DELETE_EXPR], deltype);
6300   }
6301
6302   abort_fndecl
6303     = define_function ("__pure_virtual", void_ftype, 0, 0);
6304
6305   /* Perform other language dependent initializations.  */
6306   init_class_processing ();
6307   init_init_processing ();
6308   init_search_processing ();
6309   init_rtti_processing ();
6310
6311   if (flag_exceptions)
6312     init_exception_processing ();
6313   if (flag_no_inline)
6314     {
6315       flag_inline_functions = 0;
6316     }
6317
6318   if (! supports_one_only ())
6319     flag_weak = 0;
6320
6321   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6322   declare_function_name ();
6323
6324   /* Prepare to check format strings against argument lists.  */
6325   init_function_format_info ();
6326
6327   /* Show we use EH for cleanups.  */
6328   using_eh_for_cleanups ();
6329
6330   print_error_function = lang_print_error_function;
6331   lang_get_alias_set = &c_get_alias_set;
6332   valid_lang_attribute = cp_valid_lang_attribute;
6333
6334   /* Maintain consistency.  Perhaps we should just complain if they
6335      say -fwritable-strings?  */
6336   if (flag_writable_strings)
6337     flag_const_strings = 0;
6338
6339   /* Add GC roots for all of our global variables.  */
6340   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6341   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6342   ggc_add_tree_root (&integer_three_node, 1);
6343   ggc_add_tree_root (&integer_two_node, 1);
6344   ggc_add_tree_root (&signed_size_zero_node, 1);
6345   ggc_add_tree_root (&size_one_node, 1);
6346   ggc_add_tree_root (&size_zero_node, 1);
6347   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6348                 mark_binding_level);
6349   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6350   ggc_add_tree_root (&static_ctors, 1);
6351   ggc_add_tree_root (&static_dtors, 1);
6352   ggc_add_tree_root (&lastiddecl, 1);
6353
6354   ggc_add_tree_root (&last_function_parm_tags, 1);
6355   ggc_add_tree_root (&current_function_return_value, 1);
6356   ggc_add_tree_root (&current_function_parms, 1);
6357   ggc_add_tree_root (&current_function_parm_tags, 1);
6358   ggc_add_tree_root (&last_function_parms, 1);
6359   ggc_add_tree_root (&error_mark_list, 1);
6360
6361   ggc_add_tree_root (&global_namespace, 1);
6362   ggc_add_tree_root (&global_type_node, 1);
6363   ggc_add_tree_root (&anonymous_namespace_name, 1);
6364
6365   ggc_add_tree_root (&got_object, 1);
6366   ggc_add_tree_root (&got_scope, 1);
6367
6368   ggc_add_tree_root (&current_lang_name, 1);
6369   ggc_add_tree_root (&static_aggregates, 1);
6370 }
6371
6372 /* Function to print any language-specific context for an error message.  */
6373
6374 static void
6375 lang_print_error_function (file)
6376      const char *file;
6377 {
6378   default_print_error_function (file);
6379   maybe_print_template_context ();
6380 }
6381
6382 /* Make a definition for a builtin function named NAME and whose data type
6383    is TYPE.  TYPE should be a function type with argument types.
6384
6385    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6386    the name to be called if we can't opencode the function.  */
6387
6388 tree
6389 define_function (name, type, pfn, library_name)
6390      const char *name;
6391      tree type;
6392      void (*pfn) PROTO((tree));
6393      const char *library_name;
6394 {
6395   tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
6396   DECL_EXTERNAL (decl) = 1;
6397   TREE_PUBLIC (decl) = 1;
6398   DECL_ARTIFICIAL (decl) = 1;
6399
6400   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6401   DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6402
6403   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6404      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6405      function in the namespace.  */
6406   if (pfn) (*pfn) (decl);
6407   if (library_name)
6408     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
6409   make_function_rtl (decl);
6410   return decl;
6411 }
6412
6413
6414 /* Wrapper around define_function, for the benefit of
6415    c_common_nodes_and_builtins.
6416    FUNCTION_CODE tells later passes how to compile calls to this function.
6417    See tree.h for its possible values.  */
6418
6419 tree
6420 builtin_function (name, type, code, class, libname)
6421      const char *name;
6422      tree type;
6423      int code;
6424      enum built_in_class class;
6425      const char *libname;
6426 {
6427   tree decl = define_function (name, type, (void (*) PROTO((tree)))pushdecl,
6428                                libname);
6429   DECL_BUILT_IN_CLASS (decl) = class;
6430   DECL_FUNCTION_CODE (decl) = code;
6431   return decl;
6432 }
6433 \f
6434 /* When we call finish_struct for an anonymous union, we create
6435    default copy constructors and such.  But, an anonymous union
6436    shouldn't have such things; this function undoes the damage to the
6437    anonymous union type T.
6438
6439    (The reason that we create the synthesized methods is that we don't
6440    distinguish `union { int i; }' from `typedef union { int i; } U'.
6441    The first is an anonymous union; the second is just an ordinary
6442    union type.)  */
6443
6444 void
6445 fixup_anonymous_aggr (t)
6446      tree t;
6447 {
6448   tree *q;
6449
6450   /* Wipe out memory of synthesized methods */
6451   TYPE_HAS_CONSTRUCTOR (t) = 0;
6452   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6453   TYPE_HAS_INIT_REF (t) = 0;
6454   TYPE_HAS_CONST_INIT_REF (t) = 0;
6455   TYPE_HAS_ASSIGN_REF (t) = 0;
6456   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6457
6458   /* Splice the implicitly generated functions out of the TYPE_METHODS
6459      list.  */
6460   q = &TYPE_METHODS (t);
6461   while (*q)
6462     {
6463       if (DECL_ARTIFICIAL (*q))
6464         *q = TREE_CHAIN (*q);
6465       else
6466         q = &TREE_CHAIN (*q);
6467     }
6468
6469   /* ANSI C++ June 5 1992 WP 9.5.3.  Anonymous unions may not have
6470      function members.  */
6471   if (TYPE_METHODS (t))
6472     error ("an anonymous union cannot have function members");
6473 }
6474
6475 /* Make sure that a declaration with no declarator is well-formed, i.e.
6476    just defines a tagged type or anonymous union.
6477
6478    Returns the type defined, if any.  */
6479
6480 tree
6481 check_tag_decl (declspecs)
6482      tree declspecs;
6483 {
6484   int found_type = 0;
6485   tree ob_modifier = NULL_TREE;
6486   register tree link;
6487   register tree t = NULL_TREE;
6488
6489   for (link = declspecs; link; link = TREE_CHAIN (link))
6490     {
6491       register tree value = TREE_VALUE (link);
6492
6493       if (TYPE_P (value))
6494         {
6495           ++found_type;
6496
6497           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6498             {
6499               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6500               t = value;
6501             }
6502         }
6503       else if (value == ridpointers[(int) RID_FRIEND])
6504         {
6505           if (current_class_type == NULL_TREE
6506               || current_scope () != current_class_type)
6507             ob_modifier = value;
6508         }
6509       else if (value == ridpointers[(int) RID_STATIC]
6510                || value == ridpointers[(int) RID_EXTERN]
6511                || value == ridpointers[(int) RID_AUTO]
6512                || value == ridpointers[(int) RID_REGISTER]
6513                || value == ridpointers[(int) RID_INLINE]
6514                || value == ridpointers[(int) RID_VIRTUAL]
6515                || value == ridpointers[(int) RID_CONST]
6516                || value == ridpointers[(int) RID_VOLATILE]
6517                || value == ridpointers[(int) RID_EXPLICIT])
6518         ob_modifier = value;
6519     }
6520
6521   if (found_type > 1)
6522     error ("multiple types in one declaration");
6523
6524   /* Inside a class, we might be in a friend or access declaration.
6525      Until we have a good way of detecting the latter, don't warn.  */
6526   if (t == NULL_TREE && ! current_class_type)
6527     pedwarn ("declaration does not declare anything");
6528
6529   /* Check for an anonymous union.  We're careful
6530      accessing TYPE_IDENTIFIER because some built-in types, like
6531      pointer-to-member types, do not have TYPE_NAME.  */
6532   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6533            && TYPE_NAME (t)
6534            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6535     {
6536       /* Anonymous unions are objects, so they can have specifiers.  */;
6537       SET_ANON_AGGR_TYPE_P (t);
6538
6539       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6540         pedwarn ("ISO C++ prohibits anonymous structs");
6541     }
6542
6543   else if (ob_modifier)
6544     {
6545       if (ob_modifier == ridpointers[(int) RID_INLINE]
6546           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6547         cp_error ("`%D' can only be specified for functions", ob_modifier);
6548       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6549         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6550       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6551         cp_error ("`%D' can only be specified for constructors",
6552                   ob_modifier);
6553       else
6554         cp_error ("`%D' can only be specified for objects and functions",
6555                   ob_modifier);
6556     }
6557
6558   return t;
6559 }
6560
6561 /* Called when a declaration is seen that contains no names to declare.
6562    If its type is a reference to a structure, union or enum inherited
6563    from a containing scope, shadow that tag name for the current scope
6564    with a forward reference.
6565    If its type defines a new named structure or union
6566    or defines an enum, it is valid but we need not do anything here.
6567    Otherwise, it is an error.
6568
6569    C++: may have to grok the declspecs to learn about static,
6570    complain for anonymous unions.  */
6571
6572 void
6573 shadow_tag (declspecs)
6574      tree declspecs;
6575 {
6576   tree t = check_tag_decl (declspecs);
6577
6578   if (t)
6579     maybe_process_partial_specialization (t);
6580
6581   /* This is where the variables in an anonymous union are
6582      declared.  An anonymous union declaration looks like:
6583      union { ... } ;
6584      because there is no declarator after the union, the parser
6585      sends that declaration here.  */
6586   if (t && ANON_AGGR_TYPE_P (t))
6587     {
6588       fixup_anonymous_aggr (t);
6589
6590       if (TYPE_FIELDS (t))
6591         {
6592           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6593                                       NULL_TREE);
6594           finish_anon_union (decl);
6595         }
6596     }
6597 }
6598 \f
6599 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6600
6601 tree
6602 groktypename (typename)
6603      tree typename;
6604 {
6605   if (TREE_CODE (typename) != TREE_LIST)
6606     return typename;
6607   return grokdeclarator (TREE_VALUE (typename),
6608                          TREE_PURPOSE (typename),
6609                          TYPENAME, 0, NULL_TREE);
6610 }
6611
6612 /* Decode a declarator in an ordinary declaration or data definition.
6613    This is called as soon as the type information and variable name
6614    have been parsed, before parsing the initializer if any.
6615    Here we create the ..._DECL node, fill in its type,
6616    and put it on the list of decls for the current context.
6617    The ..._DECL node is returned as the value.
6618
6619    Exception: for arrays where the length is not specified,
6620    the type is left null, to be filled in by `cp_finish_decl'.
6621
6622    Function definitions do not come here; they go to start_function
6623    instead.  However, external and forward declarations of functions
6624    do go through here.  Structure field declarations are done by
6625    grokfield and not through here.  */
6626
6627 /* Set this to zero to debug not using the temporary obstack
6628    to parse initializers.  */
6629 int debug_temp_inits = 1;
6630
6631 tree
6632 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6633      tree declarator, declspecs;
6634      int initialized;
6635      tree attributes, prefix_attributes;
6636 {
6637   register tree decl;
6638   register tree type, tem;
6639   tree context;
6640   extern int have_extern_spec;
6641   extern int used_extern_spec;
6642   tree attrlist;
6643
6644 #if 0
6645   /* See code below that used this.  */
6646   int init_written = initialized;
6647 #endif
6648
6649   /* This should only be done once on the top most decl.  */
6650   if (have_extern_spec && !used_extern_spec)
6651     {
6652       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6653                                   declspecs);
6654       used_extern_spec = 1;
6655     }
6656
6657   if (attributes || prefix_attributes)
6658     attrlist = build_scratch_list (attributes, prefix_attributes);
6659   else
6660     attrlist = NULL_TREE;
6661
6662   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6663                          attrlist);
6664
6665   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6666     return NULL_TREE;
6667
6668   type = TREE_TYPE (decl);
6669
6670   if (type == error_mark_node)
6671     return NULL_TREE;
6672
6673   context
6674     = (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
6675       ? DECL_CLASS_CONTEXT (decl)
6676       : DECL_CONTEXT (decl);
6677
6678   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
6679       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
6680     {
6681       /* When parsing the initializer, lookup should use the object's
6682          namespace. */
6683       push_decl_namespace (context);
6684     }
6685
6686   /* We are only interested in class contexts, later. */
6687   if (context && TREE_CODE (context) == NAMESPACE_DECL)
6688     context = NULL_TREE;
6689
6690   if (initialized)
6691     /* Is it valid for this decl to have an initializer at all?
6692        If not, set INITIALIZED to zero, which will indirectly
6693        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6694     switch (TREE_CODE (decl))
6695       {
6696       case TYPE_DECL:
6697         /* typedef foo = bar  means give foo the same type as bar.
6698            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6699            Any other case of an initialization in a TYPE_DECL is an error.  */
6700         if (pedantic || list_length (declspecs) > 1)
6701           {
6702             cp_error ("typedef `%D' is initialized", decl);
6703             initialized = 0;
6704           }
6705         break;
6706
6707       case FUNCTION_DECL:
6708         cp_error ("function `%#D' is initialized like a variable", decl);
6709         initialized = 0;
6710         break;
6711
6712       default:
6713         break;
6714       }
6715
6716   if (initialized)
6717     {
6718       if (! toplevel_bindings_p ()
6719           && DECL_EXTERNAL (decl))
6720         cp_warning ("declaration of `%#D' has `extern' and is initialized",
6721                     decl);
6722       DECL_EXTERNAL (decl) = 0;
6723       if (toplevel_bindings_p ())
6724         TREE_STATIC (decl) = 1;
6725
6726       /* Tell `pushdecl' this is an initialized decl
6727          even though we don't yet have the initializer expression.
6728          Also tell `cp_finish_decl' it may store the real initializer.  */
6729       DECL_INITIAL (decl) = error_mark_node;
6730     }
6731
6732 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
6733   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
6734 #endif
6735
6736   /* Set attributes here so if duplicate decl, will have proper attributes.  */
6737   cplus_decl_attributes (decl, attributes, prefix_attributes);
6738
6739   if (context && TYPE_SIZE (complete_type (context)) != NULL_TREE)
6740     {
6741       push_nested_class (context, 2);
6742
6743       if (TREE_CODE (decl) == VAR_DECL)
6744         {
6745           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
6746           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
6747             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
6748           else
6749             {
6750               if (DECL_CONTEXT (field) != context)
6751                 {
6752                   cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6753                               DECL_CONTEXT (field), DECL_NAME (decl),
6754                               context, DECL_NAME (decl));
6755                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
6756                 }
6757               /* Static data member are tricky; an in-class initialization
6758                  still doesn't provide a definition, so the in-class
6759                  declaration will have DECL_EXTERNAL set, but will have an
6760                  initialization.  Thus, duplicate_decls won't warn
6761                  about this situation, and so we check here.  */
6762               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
6763                 cp_error ("duplicate initialization of %D", decl);
6764               if (duplicate_decls (decl, field))
6765                 decl = field;
6766             }
6767         }
6768       else
6769         {
6770           tree field = check_classfn (context, decl);
6771           if (field && duplicate_decls (decl, field))
6772             decl = field;
6773         }
6774
6775       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
6776       DECL_IN_AGGR_P (decl) = 0;
6777       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
6778           || CLASSTYPE_USE_TEMPLATE (context))
6779         {
6780           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
6781           /* [temp.expl.spec] An explicit specialization of a static data
6782              member of a template is a definition if the declaration
6783              includes an initializer; otherwise, it is a declaration.
6784
6785              We check for processing_specialization so this only applies
6786              to the new specialization syntax.  */
6787           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
6788             DECL_EXTERNAL (decl) = 1;
6789         }
6790
6791       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
6792         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6793                     decl);
6794     }
6795
6796   /* Enter this declaration into the symbol table.  */
6797   tem = maybe_push_decl (decl);
6798
6799   if (processing_template_decl)
6800     tem = push_template_decl (tem);
6801
6802 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6803   /* Tell the back-end to use or not use .common as appropriate.  If we say
6804      -fconserve-space, we want this to save .data space, at the expense of
6805      wrong semantics.  If we say -fno-conserve-space, we want this to
6806      produce errors about redefs; to do this we force variables into the
6807      data segment.  */
6808   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
6809 #endif
6810
6811   if (! processing_template_decl)
6812     start_decl_1 (tem);
6813
6814   return tem;
6815 }
6816
6817 void
6818 start_decl_1 (decl)
6819      tree decl;
6820 {
6821   tree type = TREE_TYPE (decl);
6822   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
6823
6824   if (type == error_mark_node)
6825     return;
6826
6827   /* If this type of object needs a cleanup, but we're not allowed to
6828      add any more objects with cleanups to the current scope, create a
6829      new binding level.  */
6830   if (TYPE_NEEDS_DESTRUCTOR (type)
6831       && current_binding_level->more_cleanups_ok == 0)
6832     {
6833       keep_next_level (2);
6834       pushlevel (1);
6835       clear_last_expr ();
6836       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
6837     }
6838
6839   if (initialized)
6840     /* Is it valid for this decl to have an initializer at all?
6841        If not, set INITIALIZED to zero, which will indirectly
6842        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6843     {
6844       /* Don't allow initializations for incomplete types except for
6845          arrays which might be completed by the initialization.  */
6846       if (TYPE_SIZE (complete_type (type)) != NULL_TREE)
6847         ;                       /* A complete type is ok.  */
6848       else if (TREE_CODE (type) != ARRAY_TYPE)
6849         {
6850           cp_error ("variable `%#D' has initializer but incomplete type",
6851                     decl);
6852           initialized = 0;
6853           type = TREE_TYPE (decl) = error_mark_node;
6854         }
6855       else if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
6856         {
6857           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
6858             cp_error ("elements of array `%#D' have incomplete type", decl);
6859           /* else we already gave an error in start_decl.  */
6860           initialized = 0;
6861         }
6862     }
6863
6864   if (!initialized
6865       && TREE_CODE (decl) != TYPE_DECL
6866       && TREE_CODE (decl) != TEMPLATE_DECL
6867       && IS_AGGR_TYPE (type) && ! DECL_EXTERNAL (decl))
6868     {
6869       if ((! processing_template_decl || ! uses_template_parms (type))
6870           && TYPE_SIZE (complete_type (type)) == NULL_TREE)
6871         {
6872           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6873                  decl);
6874           /* Change the type so that assemble_variable will give
6875              DECL an rtl we can live with: (mem (const_int 0)).  */
6876           type = TREE_TYPE (decl) = error_mark_node;
6877         }
6878       else
6879         {
6880           /* If any base type in the hierarchy of TYPE needs a constructor,
6881              then we set initialized to 1.  This way any nodes which are
6882              created for the purposes of initializing this aggregate
6883              will live as long as it does.  This is necessary for global
6884              aggregates which do not have their initializers processed until
6885              the end of the file.  */
6886           initialized = TYPE_NEEDS_CONSTRUCTING (type);
6887         }
6888     }
6889
6890   if (! initialized)
6891     DECL_INITIAL (decl) = NULL_TREE;
6892 }
6893
6894 /* Handle initialization of references.
6895    These three arguments are from `cp_finish_decl', and have the
6896    same meaning here that they do there.
6897
6898    Quotes on semantics can be found in ARM 8.4.3.  */
6899
6900 static void
6901 grok_reference_init (decl, type, init)
6902      tree decl, type, init;
6903 {
6904   tree tmp;
6905
6906   if (init == NULL_TREE)
6907     {
6908       if ((DECL_LANG_SPECIFIC (decl) == 0
6909            || DECL_IN_AGGR_P (decl) == 0)
6910           && ! DECL_THIS_EXTERN (decl))
6911         cp_error ("`%D' declared as reference but not initialized", decl);
6912       return;
6913     }
6914
6915   if (init == error_mark_node)
6916     return;
6917
6918   if (TREE_CODE (init) == CONSTRUCTOR)
6919     {
6920       cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl);
6921       return;
6922     }
6923
6924   if (TREE_CODE (init) == TREE_LIST)
6925     init = build_compound_expr (init);
6926
6927   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
6928     init = convert_from_reference (init);
6929
6930   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
6931       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
6932     {
6933       /* Note: default conversion is only called in very special cases.  */
6934       init = default_conversion (init);
6935     }
6936
6937   /* Convert INIT to the reference type TYPE.  This may involve the
6938      creation of a temporary, whose lifetime must be the same as that
6939      of the reference.  If so, a DECL_STMT for the temporary will be
6940      added just after the DECL_STMT for DECL.  That's why we don't set
6941      DECL_INITIAL for local references (instead assigning to them
6942      explicitly); we need to allow the temporary to be initialized
6943      first.  */
6944   tmp = convert_to_reference
6945     (type, init, CONV_IMPLICIT,
6946      LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
6947
6948   if (tmp == error_mark_node)
6949     return;
6950   else if (tmp != NULL_TREE)
6951     {
6952       init = tmp;
6953       tmp = save_expr (tmp);
6954       if (building_stmt_tree ())
6955         {
6956           /* Initialize the declaration.  */
6957           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
6958           finish_expr_stmt (tmp);
6959         }
6960       else
6961         DECL_INITIAL (decl) = tmp;
6962     }
6963   else
6964     {
6965       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
6966       return;
6967     }
6968
6969   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
6970     {
6971       expand_static_init (decl, DECL_INITIAL (decl));
6972       DECL_INITIAL (decl) = NULL_TREE;
6973     }
6974   return;
6975 }
6976
6977 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
6978    mucking with forces it does not comprehend (i.e. initialization with a
6979    constructor).  If we are at global scope and won't go into COMMON, fill
6980    it in with a dummy CONSTRUCTOR to force the variable into .data;
6981    otherwise we can use error_mark_node.  */
6982
6983 static tree
6984 obscure_complex_init (decl, init)
6985      tree decl, init;
6986 {
6987   if (! flag_no_inline && TREE_STATIC (decl))
6988     {
6989       if (extract_init (decl, init))
6990         return NULL_TREE;
6991     }
6992
6993 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6994   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
6995     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
6996                                  NULL_TREE);
6997   else
6998 #endif
6999     DECL_INITIAL (decl) = error_mark_node;
7000
7001   return init;
7002 }
7003
7004 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7005    array until we finish parsing the initializer.  If that's the
7006    situation we're in, update DECL accordingly.  */
7007
7008 static void
7009 maybe_deduce_size_from_array_init (decl, init)
7010      tree decl;
7011      tree init;
7012 {
7013   tree type = TREE_TYPE (decl);
7014
7015   if (TREE_CODE (type) == ARRAY_TYPE
7016       && TYPE_DOMAIN (type) == NULL_TREE
7017       && TREE_CODE (decl) != TYPE_DECL)
7018     {
7019       int do_default
7020         = (TREE_STATIC (decl)
7021            /* Even if pedantic, an external linkage array
7022               may have incomplete type at first.  */
7023            ? pedantic && ! DECL_EXTERNAL (decl)
7024            : !DECL_EXTERNAL (decl));
7025       tree initializer = init ? init : DECL_INITIAL (decl);
7026       int failure = complete_array_type (type, initializer, do_default);
7027
7028       if (failure == 1)
7029         cp_error ("initializer fails to determine size of `%D'", decl);
7030
7031       if (failure == 2)
7032         {
7033           if (do_default)
7034             cp_error ("array size missing in `%D'", decl);
7035           /* If a `static' var's size isn't known, make it extern as
7036              well as static, so it does not get allocated.  If it's not
7037              `static', then don't mark it extern; finish_incomplete_decl
7038              will give it a default size and it will get allocated.  */
7039           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7040             DECL_EXTERNAL (decl) = 1;
7041         }
7042
7043       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7044           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7045                               integer_zero_node))
7046         cp_error ("zero-size array `%D'", decl);
7047
7048       layout_decl (decl, 0);
7049     }
7050 }
7051
7052 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7053    any appropriate error messages regarding the layout.  */
7054
7055 static void
7056 layout_var_decl (decl)
7057      tree decl;
7058 {
7059   tree type = TREE_TYPE (decl);
7060 #if 0
7061   tree ttype = target_type (type);
7062 #endif
7063
7064   /* If we haven't already layed out this declaration, do so now.
7065      Note that we must not call complete type for an external object
7066      because it's type might involve templates that we are not
7067      supposed to isntantiate yet.  (And it's perfectly legal to say
7068      `extern X x' for some incomplete type `X'.)  */
7069   if (!DECL_EXTERNAL (decl))
7070     complete_type (type);
7071   if (!DECL_SIZE (decl)&& TYPE_SIZE (type))
7072     layout_decl (decl, 0);
7073
7074   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7075     {
7076       /* An automatic variable with an incomplete type: that is an error.
7077          Don't talk about array types here, since we took care of that
7078          message in grokdeclarator.  */
7079       cp_error ("storage size of `%D' isn't known", decl);
7080       TREE_TYPE (decl) = error_mark_node;
7081     }
7082 #if 0
7083   /* Keep this code around in case we later want to control debug info
7084      based on whether a type is "used".  (jason 1999-11-11) */
7085
7086   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7087     /* Let debugger know it should output info for this type.  */
7088     note_debug_info_needed (ttype);
7089
7090   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7091     note_debug_info_needed (DECL_CONTEXT (decl));
7092 #endif
7093
7094   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7095       && DECL_SIZE (decl) != NULL_TREE
7096       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7097     {
7098       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7099         constant_expression_warning (DECL_SIZE (decl));
7100       else
7101         cp_error ("storage size of `%D' isn't constant", decl);
7102     }
7103 }
7104
7105 /* If a local static variable is declared in an inline function, or if
7106    we have a weak definition, we must endeavor to create only one
7107    instance of the variable at link-time.  */
7108
7109 static void
7110 maybe_commonize_var (decl)
7111      tree decl;
7112 {
7113   /* Static data in a function with comdat linkage also has comdat
7114      linkage.  */
7115   if (TREE_STATIC (decl)
7116       /* Don't mess with __FUNCTION__.  */
7117       && ! TREE_ASM_WRITTEN (decl)
7118       && current_function_decl
7119       && DECL_CONTEXT (decl) == current_function_decl
7120       && (DECL_THIS_INLINE (current_function_decl)
7121           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7122       && TREE_PUBLIC (current_function_decl))
7123     {
7124       /* Rather than try to get this right with inlining, we suppress
7125          inlining of such functions.  */
7126       current_function_cannot_inline
7127         = "function with static variable cannot be inline";
7128
7129       /* If flag_weak, we don't need to mess with this, as we can just
7130          make the function weak, and let it refer to its unique local
7131          copy.  This works because we don't allow the function to be
7132          inlined.  */
7133       if (! flag_weak)
7134         {
7135           if (DECL_INTERFACE_KNOWN (current_function_decl))
7136             {
7137               TREE_PUBLIC (decl) = 1;
7138               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7139             }
7140           else if (DECL_INITIAL (decl) == NULL_TREE
7141                    || DECL_INITIAL (decl) == error_mark_node)
7142             {
7143               TREE_PUBLIC (decl) = 1;
7144               DECL_COMMON (decl) = 1;
7145             }
7146           /* else we lose. We can only do this if we can use common,
7147              which we can't if it has been initialized.  */
7148
7149           if (TREE_PUBLIC (decl))
7150             DECL_ASSEMBLER_NAME (decl)
7151               = build_static_name (current_function_decl, DECL_NAME (decl));
7152           else if (! DECL_ARTIFICIAL (decl))
7153             {
7154               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7155               cp_warning_at ("  you can work around this by removing the initializer", decl);
7156             }
7157         }
7158     }
7159   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7160     /* Set it up again; we might have set DECL_INITIAL since the last
7161        time.  */
7162     comdat_linkage (decl);
7163 }
7164
7165 /* Issue an error message if DECL is an uninitialized const variable.  */
7166
7167 static void
7168 check_for_uninitialized_const_var (decl)
7169      tree decl;
7170 {
7171   tree type = TREE_TYPE (decl);
7172
7173   /* ``Unless explicitly declared extern, a const object does not have
7174      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7175      7.1.6 */
7176   if (TREE_CODE (decl) == VAR_DECL
7177       && TREE_CODE (type) != REFERENCE_TYPE
7178       && CP_TYPE_CONST_P (type)
7179       && !TYPE_NEEDS_CONSTRUCTING (type)
7180       && !DECL_INITIAL (decl))
7181     cp_error ("uninitialized const `%D'", decl);
7182 }
7183
7184 /* Verify INIT (the initializer for DECL), and record the
7185    initialization in DECL_INITIAL, if appropriate.  Returns a new
7186    value for INIT.  */
7187
7188 static tree
7189 check_initializer (decl, init)
7190      tree decl;
7191      tree init;
7192 {
7193   tree type;
7194
7195   if (TREE_CODE (decl) == FIELD_DECL)
7196     return init;
7197
7198   type = TREE_TYPE (decl);
7199
7200   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7201   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7202     init = NULL_TREE;
7203
7204   /* Check the initializer.  */
7205   if (init)
7206     {
7207       /* Things that are going to be initialized need to have complete
7208          type.  */
7209       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7210
7211       if (type == error_mark_node)
7212         /* We will have already complained.  */
7213         init = NULL_TREE;
7214       else if (TYPE_SIZE (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7215         {
7216           cp_error ("variable-sized object `%D' may not be initialized", decl);
7217           init = NULL_TREE;
7218         }
7219       else if (TREE_CODE (type) == ARRAY_TYPE
7220                && !TYPE_SIZE (TREE_TYPE (type)))
7221         {
7222           cp_error ("elements of array `%#D' have incomplete type", decl);
7223           init = NULL_TREE;
7224         }
7225       else if (!TYPE_SIZE (type))
7226         {
7227           cp_error ("`%D' has incomplete type", decl);
7228           TREE_TYPE (decl) = error_mark_node;
7229           init = NULL_TREE;
7230         }
7231     }
7232
7233   if (TREE_CODE (decl) == CONST_DECL)
7234     {
7235       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7236
7237       DECL_INITIAL (decl) = init;
7238
7239       /* This will keep us from needing to worry about our obstacks.  */
7240       my_friendly_assert (init != NULL_TREE, 149);
7241       init = NULL_TREE;
7242     }
7243   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7244     {
7245       if (TREE_STATIC (decl))
7246         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7247       grok_reference_init (decl, type, init);
7248       init = NULL_TREE;
7249     }
7250   else if (init)
7251     {
7252       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7253         {
7254           if (TREE_CODE (type) == ARRAY_TYPE)
7255             init = digest_init (type, init, (tree *) 0);
7256           else if (TREE_CODE (init) == CONSTRUCTOR
7257                    && TREE_HAS_CONSTRUCTOR (init))
7258             {
7259               if (TYPE_NON_AGGREGATE_CLASS (type))
7260                 {
7261                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7262                             decl);
7263                   init = error_mark_node;
7264                 }
7265               else
7266                 goto dont_use_constructor;
7267             }
7268         }
7269       else
7270         {
7271         dont_use_constructor:
7272           if (TREE_CODE (init) != TREE_VEC)
7273             init = store_init_value (decl, init);
7274         }
7275
7276       if (init)
7277         /* We must hide the initializer so that expand_decl
7278            won't try to do something it does not understand.  */
7279         init = obscure_complex_init (decl, init);
7280     }
7281   else if (DECL_EXTERNAL (decl))
7282     ;
7283   else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
7284            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7285     {
7286       tree core_type = strip_array_types (type);
7287
7288       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7289         {
7290           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7291             cp_error ("structure `%D' with uninitialized const members", decl);
7292           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7293             cp_error ("structure `%D' with uninitialized reference members",
7294                       decl);
7295         }
7296
7297       check_for_uninitialized_const_var (decl);
7298
7299       if (TYPE_SIZE (type) != NULL_TREE
7300           && TYPE_NEEDS_CONSTRUCTING (type))
7301         init = obscure_complex_init (decl, NULL_TREE);
7302
7303     }
7304   else
7305     check_for_uninitialized_const_var (decl);
7306
7307   return init;
7308 }
7309
7310 /* If DECL is not a local variable, give it RTL.  */
7311
7312 static void
7313 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7314      tree decl;
7315      tree init;
7316      const char *asmspec;
7317 {
7318   int toplev;
7319   tree type;
7320
7321   type = TREE_TYPE (decl);
7322   toplev = toplevel_bindings_p ();
7323
7324   /* Handle non-variables up front.  */
7325   if (TREE_CODE (decl) != VAR_DECL)
7326     {
7327       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7328       return;
7329     }
7330
7331   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7332   if (asmspec)
7333     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7334
7335   if (DECL_VIRTUAL_P (decl))
7336     make_decl_rtl (decl, NULL_PTR, toplev);
7337   else if (TREE_READONLY (decl)
7338            && DECL_INITIAL (decl) != NULL_TREE
7339            && DECL_INITIAL (decl) != error_mark_node
7340            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7341     {
7342       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7343
7344       if (toplev && ! TREE_PUBLIC (decl))
7345         {
7346           /* If this is a static const, change its apparent linkage
7347              if it belongs to a #pragma interface.  */
7348           if (!interface_unknown)
7349             {
7350               TREE_PUBLIC (decl) = 1;
7351               DECL_EXTERNAL (decl) = interface_only;
7352             }
7353           make_decl_rtl (decl, asmspec, toplev);
7354         }
7355       else if (toplev)
7356         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7357     }
7358   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7359     {
7360       my_friendly_assert (TREE_STATIC (decl), 19990828);
7361
7362       if (init == NULL_TREE
7363 #ifdef DEFAULT_STATIC_DEFS
7364           /* If this code is dead, then users must
7365              explicitly declare static member variables
7366              outside the class def'n as well.  */
7367           && TYPE_NEEDS_CONSTRUCTING (type)
7368 #endif
7369           )
7370         {
7371           DECL_EXTERNAL (decl) = 1;
7372           make_decl_rtl (decl, asmspec, 1);
7373         }
7374       else
7375         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7376     }
7377   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7378            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7379     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7380 }
7381
7382 /* Create RTL for the local static variable DECL.  */
7383
7384 void
7385 make_rtl_for_local_static (decl)
7386      tree decl;
7387 {
7388   const char *asmspec = NULL;
7389
7390   /* If we inlined this variable, we could see it's declaration
7391      again.  */
7392   if (DECL_RTL (decl))
7393     return;
7394
7395   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7396     {
7397       /* The only way this situaton can occur is if the
7398          user specified a name for this DECL using the
7399          `attribute' syntax.  */
7400       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7401       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7402     }
7403
7404   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7405 }
7406
7407 /* The old ARM scoping rules injected variables declared in the
7408    initialization statement of a for-statement into the surrounding
7409    scope.  We support this usage, in order to be backward-compatible.
7410    DECL is a just-declared VAR_DECL; if necessary inject its
7411    declaration into the surrounding scope.  */
7412
7413 void
7414 maybe_inject_for_scope_var (decl)
7415      tree decl;
7416 {
7417   if (current_binding_level->is_for_scope)
7418     {
7419       struct binding_level *outer
7420         = current_binding_level->level_chain;
7421
7422       /* Check to see if the same name is already bound at the outer
7423          level, either because it was directly declared, or because a
7424          dead for-decl got preserved.  In either case, the code would
7425          not have been valid under the ARM scope rules, so clear
7426          is_for_scope for the current_binding_level.
7427
7428          Otherwise, we need to preserve the temp slot for decl to last
7429          into the outer binding level.  */
7430
7431       tree outer_binding
7432         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7433
7434       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7435           && (TREE_CODE (BINDING_VALUE (outer_binding))
7436               == VAR_DECL)
7437           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7438         {
7439           BINDING_VALUE (outer_binding)
7440             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7441           current_binding_level->is_for_scope = 0;
7442         }
7443       else if (DECL_IN_MEMORY_P (decl))
7444         preserve_temp_slots (DECL_RTL (decl));
7445     }
7446 }
7447
7448 /* Generate code to initialize DECL (a local variable).  */
7449
7450 void
7451 initialize_local_var (decl, init, flags)
7452      tree decl;
7453      tree init;
7454      int flags;
7455 {
7456   tree type = TREE_TYPE (decl);
7457
7458   /* If the type is bogus, don't bother initializing the variable.  */
7459   if (type == error_mark_node)
7460     return;
7461
7462   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7463     {
7464       /* If we used it already as memory, it must stay in memory.  */
7465       DECL_INITIAL (decl) = NULL_TREE;
7466       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7467     }
7468
7469   /* Local statics are handled differently from ordinary automatic
7470      variables.  */
7471   if (TREE_STATIC (decl))
7472     {
7473       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7474           || TYPE_NEEDS_DESTRUCTOR (type))
7475         expand_static_init (decl, init);
7476       return;
7477     }
7478
7479   if (DECL_SIZE (decl) && type != error_mark_node)
7480     {
7481       int already_used;
7482
7483       /* Compute and store the initial value.  */
7484       already_used = TREE_USED (decl) || TREE_USED (type);
7485
7486       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7487         {
7488           int saved_stmts_are_full_exprs_p;
7489
7490           emit_line_note (DECL_SOURCE_FILE (decl),
7491                           DECL_SOURCE_LINE (decl));
7492           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7493           stmts_are_full_exprs_p = 1;
7494           finish_expr_stmt (build_aggr_init (decl, init, flags));
7495           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7496         }
7497
7498       /* Set this to 0 so we can tell whether an aggregate which was
7499          initialized was ever used.  Don't do this if it has a
7500          destructor, so we don't complain about the 'resource
7501          allocation is initialization' idiom.  Now set
7502          attribute((unused)) on types so decls of that type will be
7503          marked used. (see TREE_USED, above.)  */
7504       if (TYPE_NEEDS_CONSTRUCTING (type)
7505           && ! already_used
7506           && !TYPE_NEEDS_DESTRUCTOR (type)
7507           && DECL_NAME (decl))
7508         TREE_USED (decl) = 0;
7509       else if (already_used)
7510         TREE_USED (decl) = 1;
7511     }
7512 }
7513
7514 /* Generate code to destroy DECL (a local variable).  */
7515
7516 static void
7517 destroy_local_var (decl)
7518      tree decl;
7519 {
7520   tree type = TREE_TYPE (decl);
7521   tree cleanup;
7522
7523   /* Only variables get cleaned up.  */
7524   if (TREE_CODE (decl) != VAR_DECL)
7525     return;
7526
7527   /* And only things with destructors need cleaning up.  */
7528   if (!TYPE_NEEDS_DESTRUCTOR (type))
7529     return;
7530
7531   if (TREE_CODE (decl) == VAR_DECL &&
7532       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7533     /* We don't clean up things that aren't defined in this
7534        translation unit, or that need a static cleanup.  The latter
7535        are handled by finish_file.  */
7536     return;
7537
7538   /* Compute the cleanup.  */
7539   cleanup = maybe_build_cleanup (decl);
7540
7541   /* Record the cleanup required for this declaration.  */
7542   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7543       && cleanup)
7544     finish_decl_cleanup (decl, cleanup);
7545 }
7546
7547 /* Let the back-end know about DECL.  */
7548
7549 void
7550 emit_local_var (decl)
7551      tree decl;
7552 {
7553   /* Create RTL for this variable.  */
7554   if (DECL_RTL (decl))
7555     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7556        All other local variables are assigned RTL in this function.  */
7557     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
7558                         19990828);
7559   else
7560     {
7561       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7562         /* The user must have specified an assembler name for this
7563            variable.  Set that up now.  */
7564         rest_of_decl_compilation
7565           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
7566            /*top_level=*/0, /*at_end=*/0);
7567       else
7568         expand_decl (decl);
7569     }
7570
7571   /* Actually do the initialization.  */
7572   expand_start_target_temps ();
7573   expand_decl_init (decl);
7574   expand_end_target_temps ();
7575 }
7576
7577 /* Finish processing of a declaration;
7578    install its line number and initial value.
7579    If the length of an array type is not known before,
7580    it must be determined now, from the initial value, or it is an error.
7581
7582    For C++, `cp_finish_decl' must be fairly evasive:  it must keep initializers
7583    for aggregates that have constructors alive on the permanent obstack,
7584    so that the global initializing functions can be written at the end.
7585
7586    INIT0 holds the value of an initializer that should be allowed to escape
7587    the normal rules.
7588
7589    FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7590    if the (init) syntax was used.
7591
7592    For functions that take default parameters, DECL points to its
7593    "maximal" instantiation.  `cp_finish_decl' must then also declared its
7594    subsequently lower and lower forms of instantiation, checking for
7595    ambiguity as it goes.  This can be sped up later.  */
7596
7597 void
7598 cp_finish_decl (decl, init, asmspec_tree, flags)
7599      tree decl, init;
7600      tree asmspec_tree;
7601      int flags;
7602 {
7603   register tree type;
7604   tree ttype = NULL_TREE;
7605   const char *asmspec = NULL;
7606   int was_readonly = 0;
7607
7608   /* If this is 0, then we did not change obstacks.  */
7609   if (! decl)
7610     {
7611       if (init)
7612         error ("assignment (not initialization) in declaration");
7613       return;
7614     }
7615
7616   /* Handling __FUNCTION__ and its ilk in a template-function requires
7617      some special processing because we are called from
7618      language-independent code.  */
7619   if (cfun && processing_template_decl
7620       && current_function_name_declared == 2)
7621     {
7622       /* Since we're in a template function, we need to
7623          push_template_decl.  The language-independent code in
7624          declare_hidden_char_array doesn't know to do this.  */
7625       retrofit_lang_decl (decl);
7626       decl = push_template_decl (decl);
7627
7628       if (strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
7629                   "__PRETTY_FUNCTION__") == 0)
7630         {
7631           init = build (FUNCTION_NAME, const_string_type_node);
7632           DECL_PRETTY_FUNCTION_P (decl) = 1;
7633         }
7634     }
7635
7636   /* If a name was specified, get the string.  */
7637   if (asmspec_tree)
7638       asmspec = TREE_STRING_POINTER (asmspec_tree);
7639
7640   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7641     {
7642       cp_error ("Cannot initialize `%D' to namespace `%D'",
7643                 decl, init);
7644       init = NULL_TREE;
7645     }
7646
7647   if (current_class_type
7648       && DECL_REAL_CONTEXT (decl) == current_class_type
7649       && TYPE_BEING_DEFINED (current_class_type)
7650       && (DECL_INITIAL (decl) || init))
7651     DECL_DEFINED_IN_CLASS_P (decl) = 1;
7652
7653   if (TREE_CODE (decl) == VAR_DECL
7654       && DECL_CONTEXT (decl)
7655       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7656       && DECL_CONTEXT (decl) != current_namespace
7657       && init)
7658     {
7659       /* Leave the namespace of the object. */
7660       pop_decl_namespace ();
7661     }
7662
7663   type = TREE_TYPE (decl);
7664
7665   if (type == error_mark_node)
7666     return;
7667
7668   /* Add this declaration to the statement-tree.  */
7669   if (building_stmt_tree () && at_function_scope_p ())
7670     add_decl_stmt (decl);
7671
7672   if (TYPE_HAS_MUTABLE_P (type))
7673     TREE_READONLY (decl) = 0;
7674
7675   if (processing_template_decl)
7676     {
7677       if (init && DECL_INITIAL (decl))
7678         DECL_INITIAL (decl) = init;
7679       goto finish_end0;
7680     }
7681
7682   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7683   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7684
7685   /* Take care of TYPE_DECLs up front.  */
7686   if (TREE_CODE (decl) == TYPE_DECL)
7687     {
7688       if (init && DECL_INITIAL (decl))
7689         {
7690           /* typedef foo = bar; store the type of bar as the type of foo.  */
7691           TREE_TYPE (decl) = type = TREE_TYPE (init);
7692           DECL_INITIAL (decl) = init = NULL_TREE;
7693         }
7694       if (type != error_mark_node
7695           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7696         {
7697           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7698             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7699           set_identifier_type_value (DECL_NAME (decl), type);
7700           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7701         }
7702       GNU_xref_decl (current_function_decl, decl);
7703
7704       /* If we have installed this as the canonical typedef for this
7705          type, and that type has not been defined yet, delay emitting
7706          the debug information for it, as we will emit it later.  */
7707       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7708           && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
7709         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7710
7711       rest_of_decl_compilation (decl, NULL_PTR,
7712                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7713       goto finish_end;
7714     }
7715
7716   if (TREE_CODE (decl) != FUNCTION_DECL)
7717     ttype = target_type (type);
7718
7719   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7720       && TYPE_NEEDS_CONSTRUCTING (type))
7721     {
7722       /* Currently, GNU C++ puts constants in text space, making them
7723          impossible to initialize.  In the future, one would hope for
7724          an operating system which understood the difference between
7725          initialization and the running of a program.  */
7726       was_readonly = 1;
7727       TREE_READONLY (decl) = 0;
7728     }
7729
7730   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
7731     {
7732       /* This must override the asm specifier which was placed by
7733          grokclassfn.  Lay this out fresh.  */
7734       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
7735       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7736       make_decl_rtl (decl, asmspec, 0);
7737     }
7738
7739   /* Deduce size of array from initialization, if not already known.  */
7740   maybe_deduce_size_from_array_init (decl, init);
7741   init = check_initializer (decl, init);
7742
7743   GNU_xref_decl (current_function_decl, decl);
7744
7745   if (TREE_CODE (decl) == VAR_DECL)
7746     layout_var_decl (decl);
7747
7748   /* Output the assembler code and/or RTL code for variables and functions,
7749      unless the type is an undefined structure or union.
7750      If not, it will get done when the type is completed.  */
7751   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
7752       || TREE_CODE (decl) == RESULT_DECL)
7753     {
7754       if (TREE_CODE (decl) == VAR_DECL)
7755         maybe_commonize_var (decl);
7756
7757       make_rtl_for_nonlocal_decl (decl, init, asmspec);
7758
7759       if (TREE_CODE (type) == FUNCTION_TYPE
7760           || TREE_CODE (type) == METHOD_TYPE)
7761         abstract_virtuals_error (decl,
7762                                  strip_array_types (TREE_TYPE (type)));
7763       else
7764         abstract_virtuals_error (decl, strip_array_types (type));
7765
7766       if (TREE_CODE (decl) == FUNCTION_DECL)
7767         ;
7768       else if (DECL_EXTERNAL (decl)
7769                && ! (DECL_LANG_SPECIFIC (decl)
7770                      && DECL_NOT_REALLY_EXTERN (decl)))
7771         {
7772           if (init)
7773             DECL_INITIAL (decl) = init;
7774         }
7775       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
7776         {
7777           /* This is a local declaration.  */
7778           if (doing_semantic_analysis_p ())
7779             maybe_inject_for_scope_var (decl);
7780           /* Initialize the local variable.  But, if we're building a
7781              statement-tree, we'll do the initialization when we
7782              expand the tree.  */
7783           if (processing_template_decl)
7784             {
7785               if (init || DECL_INITIAL (decl) == error_mark_node)
7786                 DECL_INITIAL (decl) = init;
7787             }
7788           else
7789             {
7790               /* If we're not building RTL, then we need to do so
7791                  now.  */
7792               if (!building_stmt_tree ())
7793                 emit_local_var (decl);
7794               /* Initialize the variable.  */
7795               initialize_local_var (decl, init, flags);
7796               /* Clean up the variable.  */
7797               destroy_local_var (decl);
7798             }
7799         }
7800       else if (TREE_STATIC (decl) && type != error_mark_node)
7801         {
7802           /* Cleanups for static variables are handled by `finish_file'.  */
7803           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7804               || TYPE_NEEDS_DESTRUCTOR (type))
7805             expand_static_init (decl, init);
7806         }
7807     finish_end0:
7808
7809       /* Undo call to `pushclass' that was done in `start_decl'
7810          due to initialization of qualified member variable.
7811          I.e., Foo::x = 10;  */
7812       {
7813         tree context = DECL_REAL_CONTEXT (decl);
7814         if (context
7815             && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
7816             && (TREE_CODE (decl) == VAR_DECL
7817                 /* We also have a pushclass done that we need to undo here
7818                    if we're at top level and declare a method.  */
7819                 || TREE_CODE (decl) == FUNCTION_DECL)
7820             /* If size hasn't been set, we're still defining it,
7821                and therefore inside the class body; don't pop
7822                the binding level..  */
7823             && TYPE_SIZE (context) != NULL_TREE
7824             && context == current_class_type)
7825           pop_nested_class ();
7826       }
7827     }
7828
7829  finish_end:
7830
7831   /* If requested, warn about definitions of large data objects.  */
7832
7833   if (warn_larger_than
7834       && ! processing_template_decl
7835       && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
7836       && !DECL_EXTERNAL (decl))
7837     {
7838       register tree decl_size = DECL_SIZE (decl);
7839
7840       if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
7841         {
7842           unsigned units = TREE_INT_CST_LOW (decl_size) / BITS_PER_UNIT;
7843
7844           if (units > larger_than_size)
7845             warning_with_decl (decl, "size of `%s' is %u bytes", units);
7846         }
7847     }
7848
7849   if (was_readonly)
7850     TREE_READONLY (decl) = 1;
7851 }
7852
7853 /* This is here for a midend callback from c-common.c */
7854
7855 void
7856 finish_decl (decl, init, asmspec_tree)
7857      tree decl, init;
7858      tree asmspec_tree;
7859 {
7860   cp_finish_decl (decl, init, asmspec_tree, 0);
7861 }
7862
7863 /* Returns a declaration for a VAR_DECL as if:
7864
7865      extern "C" TYPE NAME;
7866
7867    had been seen.  Used to create compiler-generated global
7868    variables.  */
7869
7870 tree
7871 declare_global_var (name, type)
7872      tree name;
7873      tree type;
7874 {
7875   tree decl;
7876
7877   push_to_top_level ();
7878   decl = build_decl (VAR_DECL, name, type);
7879   TREE_PUBLIC (decl) = 1;
7880   DECL_EXTERNAL (decl) = 1;
7881   DECL_ARTIFICIAL (decl) = 1;
7882   pushdecl (decl);
7883   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
7884   pop_from_top_level ();
7885
7886   return decl;
7887 }
7888
7889 /* Returns a pointer to the `atexit' function.  Note that if
7890    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
7891    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
7892
7893 static tree
7894 get_atexit_node ()
7895 {
7896   tree atexit_fndecl;
7897   tree arg_types;
7898   tree fn_type;
7899   tree fn_ptr_type;
7900   const char *name;
7901
7902   if (atexit_node)
7903     return atexit_node;
7904
7905   if (flag_use_cxa_atexit)
7906     {
7907       /* The declaration for `__cxa_atexit' is:
7908
7909            int __cxa_atexit (void (*)(void *), void *, void *)
7910
7911          We build up the argument types and then then function type
7912          itself.  */
7913
7914       /* First, build the pointer-to-function type for the first
7915          argument.  */
7916       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7917       fn_type = build_function_type (void_type_node, arg_types);
7918       fn_ptr_type = build_pointer_type (fn_type);
7919       /* Then, build the rest of the argument types.  */
7920       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7921       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
7922       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
7923       /* And the final __cxa_atexit type.  */
7924       fn_type = build_function_type (integer_type_node, arg_types);
7925       fn_ptr_type = build_pointer_type (fn_type);
7926       name = "__cxa_atexit";
7927     }
7928   else
7929     {
7930       /* The declaration for `atexit' is:
7931
7932            int atexit (void (*)());
7933
7934          We build up the argument types and then then function type
7935          itself.  */
7936       fn_type = build_function_type (void_type_node, void_list_node);
7937       fn_ptr_type = build_pointer_type (fn_type);
7938       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
7939       /* Build the final atexit type.  */
7940       fn_type = build_function_type (integer_type_node, arg_types);
7941       name = "atexit";
7942     }
7943
7944   /* Now, build the function declaration.  */
7945   push_lang_context (lang_name_c);
7946   atexit_fndecl = define_function (name, fn_type, /*pfn=*/0, NULL_PTR);
7947   mark_used (atexit_fndecl);
7948   pop_lang_context ();
7949   atexit_node = default_conversion (atexit_fndecl);
7950
7951   return atexit_node;
7952 }
7953
7954 /* Returns the __dso_handle VAR_DECL.  */
7955
7956 static tree
7957 get_dso_handle_node ()
7958 {
7959   if (dso_handle_node)
7960     return dso_handle_node;
7961
7962   /* Declare the variable.  */
7963   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
7964                                         ptr_type_node);
7965
7966   return dso_handle_node;
7967 }
7968
7969 /* Begin a new function with internal linkage whose job will be simply
7970    to destroy some particular variable.  */
7971
7972 static tree
7973 start_cleanup_fn ()
7974 {
7975   static int counter = 0;
7976   int old_interface_unknown = interface_unknown;
7977   char name[32];
7978   tree parmtypes;
7979   tree fntype;
7980   tree fndecl;
7981
7982   push_to_top_level ();
7983
7984   /* No need to mangle this.  */
7985   push_lang_context (lang_name_c);
7986
7987   interface_unknown = 1;
7988
7989   /* Build the parameter-types.  */
7990   parmtypes = void_list_node;
7991   /* Functions passed to __cxa_atexit take an additional parameter.
7992      We'll just ignore it.  After we implement the new calling
7993      convention for destructors, we can eliminate the use of
7994      additional cleanup functions entirely in the -fnew-abi case.  */
7995   if (flag_use_cxa_atexit)
7996     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
7997   /* Build the function type itself.  */
7998   fntype = build_function_type (void_type_node, parmtypes);
7999   /* Build the name of the function.  */
8000   sprintf (name, "__tcf_%d", counter++);
8001   /* Build the function declaration.  */
8002   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8003   /* It's a function with internal linkage, generated by the
8004      compiler.  */
8005   TREE_PUBLIC (fndecl) = 0;
8006   DECL_ARTIFICIAL (fndecl) = 1;
8007   /* Build the parameter.  */
8008   if (flag_use_cxa_atexit)
8009     {
8010       tree parmdecl;
8011
8012       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8013       DECL_CONTEXT (parmdecl) = fndecl;
8014       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8015       TREE_USED (parmdecl) = 1;
8016       DECL_ARGUMENTS (fndecl) = parmdecl;
8017     }
8018
8019   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8020   do_pushlevel ();
8021
8022   interface_unknown = old_interface_unknown;
8023
8024   pop_lang_context ();
8025
8026   return current_function_decl;
8027 }
8028
8029 /* Finish the cleanup function begun by start_cleanup_fn.  */
8030
8031 static void
8032 end_cleanup_fn ()
8033 {
8034   do_poplevel ();
8035
8036   expand_body (finish_function (lineno, 0));
8037
8038   pop_from_top_level ();
8039 }
8040
8041 /* Generate code to handle the destruction of the function-scoped
8042    static variable DECL.  */
8043
8044 static void
8045 destroy_local_static (decl)
8046      tree decl;
8047 {
8048   tree cleanup;
8049   tree compound_stmt;
8050   tree args;
8051   tree fcall;
8052
8053   int saved_flag_access_control;
8054
8055   /* Call build_cleanup before we enter the anonymous function so that
8056      any access checks will be done relative to the current scope,
8057      rather than the scope of the anonymous function.  */
8058   build_cleanup (decl);
8059
8060   /* Now start the function.  */
8061   cleanup = start_cleanup_fn ();
8062
8063   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8064      to the original function, rather than the anonymous one.  That
8065      will make the back-end think that nested functions are in use,
8066      which causes confusion.  */
8067   saved_flag_access_control = flag_access_control;
8068   flag_access_control = 0;
8069   fcall = build_cleanup (decl);
8070   flag_access_control = saved_flag_access_control;
8071
8072   /* Create the body of the anonymous function.  */
8073   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8074   finish_expr_stmt (fcall);
8075   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8076   end_cleanup_fn ();
8077
8078   /* Call atexit with the cleanup function.  */
8079   mark_addressable (cleanup);
8080   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8081   if (flag_use_cxa_atexit)
8082     {
8083       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8084       args = tree_cons (NULL_TREE, null_pointer_node, args);
8085       args = tree_cons (NULL_TREE, cleanup, args);
8086     }
8087   else
8088     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8089   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8090 }
8091
8092 void
8093 expand_static_init (decl, init)
8094      tree decl;
8095      tree init;
8096 {
8097   tree oldstatic = value_member (decl, static_aggregates);
8098
8099   if (oldstatic)
8100     {
8101       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8102         cp_error ("multiple initializations given for `%D'", decl);
8103     }
8104   else if (! toplevel_bindings_p ())
8105     {
8106       /* Emit code to perform this initialization but once.  */
8107       tree temp;
8108       tree if_stmt;
8109       tree then_clause;
8110       tree assignment;
8111       tree temp_init;
8112
8113       /* Emit code to perform this initialization but once.  This code
8114          looks like:
8115
8116            static int temp = 0;
8117            if (!temp) {
8118              // Do initialization.
8119              temp = 1;
8120              // Register variable for destruction at end of program.
8121            }
8122
8123          Note that the `temp' variable is only set to 1 *after* the
8124          initialization is complete.  This ensures that an exception,
8125          thrown during the construction, will cause the variable to
8126          reinitialized when we pass through this code again, as per:
8127
8128            [stmt.dcl]
8129
8130            If the initialization exits by throwing an exception, the
8131            initialization is not complete, so it will be tried again
8132            the next time control enters the declaration.
8133
8134          In theory, this process should be thread-safe, too; multiple
8135          threads should not be able to initialize the variable more
8136          than once.  We don't yet attempt to ensure thread-safety.  */
8137       temp = get_temp_name (integer_type_node, 1);
8138       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8139
8140       /* Begin the conditional initialization.  */
8141       if_stmt = begin_if_stmt ();
8142       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8143                                             integer_zero_node),
8144                            if_stmt);
8145       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8146
8147       /* Do the initialization itself.  */
8148       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8149           || (init && TREE_CODE (init) == TREE_LIST))
8150         assignment = build_aggr_init (decl, init, 0);
8151       else if (init)
8152         /* The initialization we're doing here is just a bitwise
8153            copy.  */
8154         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8155       else
8156         assignment = NULL_TREE;
8157
8158       /* Once the assignment is complete, set TEMP to 1.  Since the
8159          construction of the static object is complete at this point,
8160          we want to make sure TEMP is set to 1 even if a temporary
8161          constructed during the initialization throws an exception
8162          when it is destroyed.  So, we combine the initialization and
8163          the assignment to TEMP into a single expression, ensuring
8164          that when we call finish_expr_stmt the cleanups will not be
8165          run until after TEMP is set to 1.  */
8166       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8167       if (assignment)
8168         {
8169           assignment = tree_cons (NULL_TREE, assignment,
8170                                   build_tree_list (NULL_TREE,
8171                                                    temp_init));
8172           assignment = build_compound_expr (assignment);
8173         }
8174       else
8175         assignment = temp_init;
8176       finish_expr_stmt (assignment);
8177
8178       /* Use atexit to register a function for destroying this static
8179          variable.  */
8180       if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
8181         destroy_local_static (decl);
8182
8183       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8184       finish_then_clause (if_stmt);
8185       finish_if_stmt ();
8186     }
8187   else
8188     {
8189       /* This code takes into account memory allocation policy of
8190          `start_decl'.  Namely, if TYPE_NEEDS_CONSTRUCTING does not
8191          hold for this object, then we must make permanent the storage
8192          currently in the temporary obstack.  */
8193       if (!TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
8194         preserve_initializer ();
8195       static_aggregates = tree_cons (init, decl, static_aggregates);
8196     }
8197 }
8198
8199 /* Finish the declaration of a catch-parameter.  */
8200
8201 tree
8202 start_handler_parms (declspecs, declarator)
8203      tree declspecs;
8204      tree declarator;
8205 {
8206   tree decl;
8207   if (declspecs)
8208     {
8209       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8210                              1, NULL_TREE);
8211       if (decl == NULL_TREE)
8212         error ("invalid catch parameter");
8213     }
8214   else
8215     decl = NULL_TREE;
8216
8217   return decl;
8218 }
8219
8220 \f
8221 /* Make TYPE a complete type based on INITIAL_VALUE.
8222    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8223    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8224
8225 int
8226 complete_array_type (type, initial_value, do_default)
8227      tree type, initial_value;
8228      int do_default;
8229 {
8230   register tree maxindex = NULL_TREE;
8231   int value = 0;
8232
8233   if (initial_value)
8234     {
8235       /* Note MAXINDEX  is really the maximum index,
8236          one less than the size.  */
8237       if (TREE_CODE (initial_value) == STRING_CST)
8238         {
8239           int eltsize
8240             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8241           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8242                                    / eltsize) - 1, 0);
8243         }
8244       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8245         {
8246           tree elts = CONSTRUCTOR_ELTS (initial_value);
8247           maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
8248           for (; elts; elts = TREE_CHAIN (elts))
8249             {
8250               if (TREE_PURPOSE (elts))
8251                 maxindex = TREE_PURPOSE (elts);
8252               else
8253                 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
8254             }
8255           maxindex = copy_node (maxindex);
8256         }
8257       else
8258         {
8259           /* Make an error message unless that happened already.  */
8260           if (initial_value != error_mark_node)
8261             value = 1;
8262           else
8263             initial_value = NULL_TREE;
8264
8265           /* Prevent further error messages.  */
8266           maxindex = build_int_2 (0, 0);
8267         }
8268     }
8269
8270   if (!maxindex)
8271     {
8272       if (do_default)
8273         maxindex = build_int_2 (0, 0);
8274       value = 2;
8275     }
8276
8277   if (maxindex)
8278     {
8279       tree itype;
8280       tree domain;
8281
8282       domain = build_index_type (maxindex);
8283       TYPE_DOMAIN (type) = domain;
8284
8285       if (! TREE_TYPE (maxindex))
8286         TREE_TYPE (maxindex) = domain;
8287       if (initial_value)
8288         itype = TREE_TYPE (initial_value);
8289       else
8290         itype = NULL;
8291       if (itype && !TYPE_DOMAIN (itype))
8292         TYPE_DOMAIN (itype) = domain;
8293       /* The type of the main variant should never be used for arrays
8294          of different sizes.  It should only ever be completed with the
8295          size of the array.  */
8296       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8297         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8298     }
8299
8300   /* Lay out the type now that we can get the real answer.  */
8301
8302   layout_type (type);
8303
8304   return value;
8305 }
8306 \f
8307 /* Return zero if something is declared to be a member of type
8308    CTYPE when in the context of CUR_TYPE.  STRING is the error
8309    message to print in that case.  Otherwise, quietly return 1.  */
8310
8311 static int
8312 member_function_or_else (ctype, cur_type, string)
8313      tree ctype, cur_type;
8314      const char *string;
8315 {
8316   if (ctype && ctype != cur_type)
8317     {
8318       error (string, TYPE_NAME_STRING (ctype));
8319       return 0;
8320     }
8321   return 1;
8322 }
8323 \f
8324 /* Subroutine of `grokdeclarator'.  */
8325
8326 /* Generate errors possibly applicable for a given set of specifiers.
8327    This is for ARM $7.1.2.  */
8328
8329 static void
8330 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8331      tree object;
8332      const char *type;
8333      int virtualp, quals, friendp, raises, inlinep;
8334 {
8335   if (virtualp)
8336     cp_error ("`%D' declared as a `virtual' %s", object, type);
8337   if (inlinep)
8338     cp_error ("`%D' declared as an `inline' %s", object, type);
8339   if (quals)
8340     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8341               object, type);
8342   if (friendp)
8343     cp_error_at ("`%D' declared as a friend", object);
8344   if (raises)
8345     cp_error_at ("`%D' declared with an exception specification", object);
8346 }
8347
8348 /* CTYPE is class type, or null if non-class.
8349    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8350    or METHOD_TYPE.
8351    DECLARATOR is the function's name.
8352    VIRTUALP is truthvalue of whether the function is virtual or not.
8353    FLAGS are to be passed through to `grokclassfn'.
8354    QUALS are qualifiers indicating whether the function is `const'
8355    or `volatile'.
8356    RAISES is a list of exceptions that this function can raise.
8357    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8358    not look, and -1 if we should not call `grokclassfn' at all.
8359
8360    Returns `NULL_TREE' if something goes wrong, after issuing
8361    applicable error messages.  */
8362
8363 static tree
8364 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8365             raises, check, friendp, publicp, inlinep, funcdef_flag,
8366             template_count, in_namespace)
8367      tree ctype, type;
8368      tree declarator;
8369      tree orig_declarator;
8370      int virtualp;
8371      enum overload_flags flags;
8372      tree quals, raises;
8373      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8374      tree in_namespace;
8375 {
8376   tree cname, decl;
8377   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8378   int has_default_arg = 0;
8379   tree t;
8380
8381   if (ctype)
8382     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8383       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8384   else
8385     cname = NULL_TREE;
8386
8387   if (raises)
8388     {
8389       type = build_exception_variant (type, raises);
8390     }
8391
8392   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8393   /* Propagate volatile out from type to decl. */
8394   if (TYPE_VOLATILE (type))
8395     TREE_THIS_VOLATILE (decl) = 1;
8396
8397   /* If this decl has namespace scope, set that up.  */
8398   if (in_namespace)
8399     set_decl_namespace (decl, in_namespace, friendp);
8400   else if (publicp && ! ctype)
8401     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8402
8403   /* `main' and builtins have implicit 'C' linkage.  */
8404   if ((MAIN_NAME_P (declarator)
8405        || (IDENTIFIER_LENGTH (declarator) > 10
8406            && IDENTIFIER_POINTER (declarator)[0] == '_'
8407            && IDENTIFIER_POINTER (declarator)[1] == '_'
8408            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8409       && current_lang_name == lang_name_cplusplus
8410       && ctype == NULL_TREE
8411       /* NULL_TREE means global namespace.  */
8412       && DECL_CONTEXT (decl) == NULL_TREE)
8413     DECL_LANGUAGE (decl) = lang_c;
8414
8415   /* Should probably propagate const out from type to decl I bet (mrs).  */
8416   if (staticp)
8417     {
8418       DECL_STATIC_FUNCTION_P (decl) = 1;
8419       DECL_CONTEXT (decl) = ctype;
8420     }
8421
8422   if (ctype)
8423     DECL_CLASS_CONTEXT (decl) = ctype;
8424
8425   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8426     {
8427       if (processing_template_decl)
8428         error ("cannot declare `main' to be a template");
8429       if (inlinep)
8430         error ("cannot declare `main' to be inline");
8431       else if (! publicp)
8432         error ("cannot declare `main' to be static");
8433       inlinep = 0;
8434       publicp = 1;
8435     }
8436
8437   /* Members of anonymous types and local classes have no linkage; make
8438      them internal.  */
8439   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8440                 || hack_decl_function_context (TYPE_MAIN_DECL (ctype))))
8441     publicp = 0;
8442
8443   if (publicp)
8444     {
8445       /* [basic.link]: A name with no linkage (notably, the name of a class
8446          or enumeration declared in a local scope) shall not be used to
8447          declare an entity with linkage.
8448
8449          Only check this for public decls for now.  */
8450       t = no_linkage_check (TREE_TYPE (decl));
8451       if (t)
8452         {
8453           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8454             {
8455               if (DECL_LANGUAGE (decl) == lang_c)
8456                 /* Allow this; it's pretty common in C.  */;
8457               else
8458                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8459                             decl);
8460             }
8461           else
8462             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8463                         decl, t);
8464         }
8465     }
8466
8467   TREE_PUBLIC (decl) = publicp;
8468   if (! publicp)
8469     {
8470       DECL_INTERFACE_KNOWN (decl) = 1;
8471       DECL_NOT_REALLY_EXTERN (decl) = 1;
8472     }
8473
8474   if (inlinep)
8475     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8476
8477   DECL_EXTERNAL (decl) = 1;
8478   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8479     {
8480       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8481                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8482       quals = NULL_TREE;
8483     }
8484
8485   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8486     grok_op_properties (decl, virtualp, check < 0);
8487
8488   if (ctype && hack_decl_function_context (decl))
8489     DECL_NO_STATIC_CHAIN (decl) = 1;
8490
8491   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8492     if (TREE_PURPOSE (t)
8493         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8494       {
8495         has_default_arg = 1;
8496         break;
8497       }
8498
8499   if (friendp
8500       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8501     {
8502       if (funcdef_flag)
8503         cp_error
8504           ("defining explicit specialization `%D' in friend declaration",
8505            orig_declarator);
8506       else
8507         {
8508           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8509             {
8510               /* Something like `template <class T> friend void f<T>()'.  */
8511               cp_error ("template-id `%D' in declaration of primary template",
8512                         orig_declarator);
8513               return NULL_TREE;
8514             }
8515
8516
8517           /* A friend declaration of the form friend void f<>().  Record
8518              the information in the TEMPLATE_ID_EXPR.  */
8519           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8520           DECL_TEMPLATE_INFO (decl)
8521             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8522                          TREE_OPERAND (orig_declarator, 1),
8523                          NULL_TREE);
8524
8525           if (has_default_arg)
8526             {
8527               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8528                         decl);
8529               return NULL_TREE;
8530             }
8531
8532           if (inlinep)
8533             {
8534               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8535                         decl);
8536               return NULL_TREE;
8537             }
8538         }
8539     }
8540
8541   if (has_default_arg)
8542     add_defarg_fn (decl);
8543
8544   /* Plain overloading: will not be grok'd by grokclassfn.  */
8545   if (! ctype && ! processing_template_decl
8546       && DECL_LANGUAGE (decl) != lang_c
8547       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8548     set_mangled_name_for_decl (decl);
8549
8550   if (funcdef_flag)
8551     /* Make the init_value nonzero so pushdecl knows this is not
8552        tentative.  error_mark_node is replaced later with the BLOCK.  */
8553     DECL_INITIAL (decl) = error_mark_node;
8554
8555   /* Caller will do the rest of this.  */
8556   if (check < 0)
8557     return decl;
8558
8559   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8560     {
8561       tree tmp;
8562       /* Just handle constructors here.  We could do this
8563          inside the following if stmt, but I think
8564          that the code is more legible by breaking this
8565          case out.  See comments below for what each of
8566          the following calls is supposed to do.  */
8567       DECL_CONSTRUCTOR_P (decl) = 1;
8568
8569       grokclassfn (ctype, decl, flags, quals);
8570
8571       decl = check_explicit_specialization (orig_declarator, decl,
8572                                             template_count,
8573                                             2 * (funcdef_flag != 0) +
8574                                             4 * (friendp != 0));
8575       if (decl == error_mark_node)
8576         return NULL_TREE;
8577
8578       if ((! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8579           && check)
8580         {
8581           tmp = check_classfn (ctype, decl);
8582
8583           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8584             tmp = DECL_TEMPLATE_RESULT(tmp);
8585
8586           if (tmp && DECL_ARTIFICIAL (tmp))
8587             cp_error ("definition of implicitly-declared `%D'", tmp);
8588           if (tmp && duplicate_decls (decl, tmp))
8589             return tmp;
8590         }
8591       if (! grok_ctor_properties (ctype, decl))
8592         return NULL_TREE;
8593     }
8594   else
8595     {
8596       tree tmp;
8597
8598       /* Function gets the ugly name, field gets the nice one.
8599          This call may change the type of the function (because
8600          of default parameters)!  */
8601       if (ctype != NULL_TREE)
8602         grokclassfn (ctype, decl, flags, quals);
8603
8604       decl = check_explicit_specialization (orig_declarator, decl,
8605                                             template_count,
8606                                             2 * (funcdef_flag != 0) +
8607                                             4 * (friendp != 0));
8608       if (decl == error_mark_node)
8609         return NULL_TREE;
8610
8611       if (ctype != NULL_TREE
8612           && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8613           && check)
8614         {
8615           tmp = check_classfn (ctype, decl);
8616
8617           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8618             tmp = DECL_TEMPLATE_RESULT (tmp);
8619
8620           if (tmp && DECL_STATIC_FUNCTION_P (tmp)
8621               && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8622             {
8623               /* Remove the `this' parm added by grokclassfn.
8624                  XXX Isn't this done in start_function, too?  */
8625               revert_static_member_fn (&decl, NULL, NULL);
8626               last_function_parms = TREE_CHAIN (last_function_parms);
8627             }
8628           if (tmp && DECL_ARTIFICIAL (tmp))
8629             cp_error ("definition of implicitly-declared `%D'", tmp);
8630           if (tmp)
8631             {
8632               /* Attempt to merge the declarations.  This can fail, in
8633                  the case of some illegal specialization declarations.  */
8634               if (!duplicate_decls (decl, tmp))
8635                 cp_error ("no `%#D' member function declared in class `%T'",
8636                           decl, ctype);
8637               return tmp;
8638             }
8639         }
8640
8641       if (ctype == NULL_TREE || check)
8642         return decl;
8643
8644       if (virtualp)
8645         {
8646           DECL_VIRTUAL_P (decl) = 1;
8647           if (DECL_VINDEX (decl) == NULL_TREE)
8648             DECL_VINDEX (decl) = error_mark_node;
8649           IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8650         }
8651     }
8652   return decl;
8653 }
8654
8655 static tree
8656 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8657      tree type;
8658      tree declarator;
8659      RID_BIT_TYPE *specbits_in;
8660      int initialized;
8661      int constp;
8662      tree in_namespace;
8663 {
8664   tree decl;
8665   RID_BIT_TYPE specbits;
8666
8667   specbits = *specbits_in;
8668
8669   if (TREE_CODE (type) == OFFSET_TYPE)
8670     {
8671       /* If you declare a static member so that it
8672          can be initialized, the code will reach here.  */
8673       tree basetype = TYPE_OFFSET_BASETYPE (type);
8674       type = TREE_TYPE (type);
8675       decl = build_lang_decl (VAR_DECL, declarator, type);
8676       DECL_CONTEXT (decl) = basetype;
8677       DECL_CLASS_CONTEXT (decl) = basetype;
8678       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8679     }
8680   else
8681     {
8682       tree context;
8683
8684       if (in_namespace)
8685         context = in_namespace;
8686       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8687         context = current_namespace;
8688       else
8689         context = NULL_TREE;
8690
8691       if (processing_template_decl)
8692         /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8693            we can call push_template_decl.  */
8694         decl = build_lang_decl (VAR_DECL, declarator, type);
8695       else
8696         decl = build_decl (VAR_DECL, declarator, type);
8697
8698       if (context)
8699         set_decl_namespace (decl, context, 0);
8700
8701       context = DECL_CONTEXT (decl);
8702       if (declarator && context && current_lang_name != lang_name_c)
8703         DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8704     }
8705
8706   if (in_namespace)
8707     set_decl_namespace (decl, in_namespace, 0);
8708
8709   if (RIDBIT_SETP (RID_EXTERN, specbits))
8710     {
8711       DECL_THIS_EXTERN (decl) = 1;
8712       DECL_EXTERNAL (decl) = !initialized;
8713     }
8714
8715   /* In class context, static means one per class,
8716      public access, and static storage.  */
8717   if (DECL_CLASS_SCOPE_P (decl))
8718     {
8719       TREE_PUBLIC (decl) = 1;
8720       TREE_STATIC (decl) = 1;
8721       DECL_EXTERNAL (decl) = 0;
8722     }
8723   /* At top level, either `static' or no s.c. makes a definition
8724      (perhaps tentative), and absence of `static' makes it public.  */
8725   else if (toplevel_bindings_p ())
8726     {
8727       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8728                             && (DECL_THIS_EXTERN (decl) || ! constp));
8729       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8730     }
8731   /* Not at top level, only `static' makes a static definition.  */
8732   else
8733     {
8734       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8735       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8736     }
8737
8738   if (TREE_PUBLIC (decl))
8739     {
8740       /* [basic.link]: A name with no linkage (notably, the name of a class
8741          or enumeration declared in a local scope) shall not be used to
8742          declare an entity with linkage.
8743
8744          Only check this for public decls for now.  */
8745       tree t = no_linkage_check (TREE_TYPE (decl));
8746       if (t)
8747         {
8748           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8749             /* Ignore for now; `enum { foo } e' is pretty common.  */;
8750           else
8751             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8752                         decl, t);
8753         }
8754     }
8755
8756   return decl;
8757 }
8758
8759 /* Create and return a canonical pointer to member function type, for
8760    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
8761
8762 tree
8763 build_ptrmemfunc_type (type)
8764      tree type;
8765 {
8766   tree fields[4];
8767   tree t;
8768   tree u;
8769   tree unqualified_variant = NULL_TREE;
8770
8771   /* If a canonical type already exists for this type, use it.  We use
8772      this method instead of type_hash_canon, because it only does a
8773      simple equality check on the list of field members.  */
8774
8775   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8776     return t;
8777
8778   /* Make sure that we always have the unqualified pointer-to-member
8779      type first.  */
8780   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8781     unqualified_variant
8782       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
8783
8784   u = make_aggr_type (UNION_TYPE);
8785   SET_IS_AGGR_TYPE (u, 0);
8786   fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
8787   fields[1] = build_lang_decl (FIELD_DECL, delta2_identifier,
8788                                delta_type_node);
8789   finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
8790   TYPE_NAME (u) = NULL_TREE;
8791
8792   t = make_aggr_type (RECORD_TYPE);
8793
8794   /* Let the front-end know this is a pointer to member function...  */
8795   TYPE_PTRMEMFUNC_FLAG (t) = 1;
8796   /* ... and not really an aggregate.  */
8797   SET_IS_AGGR_TYPE (t, 0);
8798
8799   fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
8800                                delta_type_node);
8801   fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
8802                                delta_type_node);
8803   fields[2] = build_lang_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
8804   finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
8805
8806   /* Zap out the name so that the back-end will give us the debugging
8807      information for this anonymous RECORD_TYPE.  */
8808   TYPE_NAME (t) = NULL_TREE;
8809
8810   /* If this is not the unqualified form of this pointer-to-member
8811      type, set the TYPE_MAIN_VARIANT for this type to be the
8812      unqualified type.  Since they are actually RECORD_TYPEs that are
8813      not variants of each other, we must do this manually.  */
8814   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8815     {
8816       t = build_qualified_type (t, CP_TYPE_QUALS (type));
8817       TYPE_MAIN_VARIANT (t) = unqualified_variant;
8818       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
8819       TYPE_NEXT_VARIANT (unqualified_variant) = t;
8820     }
8821
8822   /* Cache this pointer-to-member type so that we can find it again
8823      later.  */
8824   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
8825
8826   /* Seems to be wanted.  */
8827   CLASSTYPE_GOT_SEMICOLON (t) = 1;
8828
8829   return t;
8830 }
8831
8832 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8833    Check to see that the definition is valid.  Issue appropriate error
8834    messages.  Return 1 if the definition is particularly bad, or 0
8835    otherwise.  */
8836
8837 int
8838 check_static_variable_definition (decl, type)
8839      tree decl;
8840      tree type;
8841 {
8842   /* Motion 10 at San Diego: If a static const integral data member is
8843      initialized with an integral constant expression, the initializer
8844      may appear either in the declaration (within the class), or in
8845      the definition, but not both.  If it appears in the class, the
8846      member is a member constant.  The file-scope definition is always
8847      required.  */
8848   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
8849     {
8850       cp_error ("in-class initialization of static data member of non-integral type `%T'",
8851                 type);
8852       /* If we just return the declaration, crashes will sometimes
8853          occur.  We therefore return void_type_node, as if this was a
8854          friend declaration, to cause callers to completely ignore
8855          this declaration.  */
8856       return 1;
8857     }
8858   else if (!CP_TYPE_CONST_P (type))
8859     cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
8860               decl);
8861   else if (pedantic && !INTEGRAL_TYPE_P (type))
8862     cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
8863
8864   return 0;
8865 }
8866
8867 /* Given the SIZE (i.e., number of elements) in an array, compute an
8868    appropriate index type for the array.  If non-NULL, NAME is the
8869    name of the thing being declared.  */
8870
8871 tree
8872 compute_array_index_type (name, size)
8873      tree name;
8874      tree size;
8875 {
8876   tree itype;
8877
8878   /* The size might be the result of a cast. */
8879   STRIP_TYPE_NOPS (size);
8880
8881   /* It might be a const variable or enumeration constant.  */
8882   if (TREE_READONLY_DECL_P (size))
8883     size = decl_constant_value (size);
8884
8885   /* If this involves a template parameter, it will be a constant at
8886      instantiation time, but we don't know what the value is yet.
8887      Even if no template parameters are involved, we may an expression
8888      that is not a constant; we don't even simplify `1 + 2' when
8889      processing a template.  */
8890   if (processing_template_decl)
8891     {
8892       /* Resolve a qualified reference to an enumerator or static
8893          const data member of ours.  */
8894       if (TREE_CODE (size) == SCOPE_REF
8895           && TREE_OPERAND (size, 0) == current_class_type)
8896         {
8897           tree t = lookup_field (current_class_type,
8898                                  TREE_OPERAND (size, 1), 0, 0);
8899           if (t)
8900             size = t;
8901         }
8902
8903       return build_index_type (build_min (MINUS_EXPR, sizetype,
8904                                           size, integer_one_node));
8905     }
8906
8907   /* The array bound must be an integer type.  */
8908   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
8909       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
8910       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
8911     {
8912       if (name)
8913         cp_error ("size of array `%D' has non-integer type", name);
8914       else
8915         cp_error ("size of array has non-integer type");
8916       size = integer_one_node;
8917     }
8918
8919   /* Normally, the array-bound will be a constant.  */
8920   if (TREE_CONSTANT (size))
8921     {
8922       /* Check to see if the array bound overflowed.  Make that an
8923          error, no matter how generous we're being.  */
8924       int old_flag_pedantic_errors = flag_pedantic_errors;
8925       int old_pedantic = pedantic;
8926       pedantic = flag_pedantic_errors = 1;
8927       constant_expression_warning (size);
8928       pedantic = old_pedantic;
8929       flag_pedantic_errors = old_flag_pedantic_errors;
8930
8931       /* An array must have a positive number of elements.  */
8932       if (INT_CST_LT (size, integer_zero_node))
8933         {
8934           if (name)
8935             cp_error ("size of array `%D' is negative", name);
8936           else
8937             cp_error ("size of array is negative");
8938           size = integer_one_node;
8939         }
8940       /* Except that an extension we allow zero-sized arrays.  We
8941          always allow them in system headers because glibc uses
8942          them.  */
8943       else if (integer_zerop (size) && pedantic && !in_system_header)
8944         {
8945           if (name)
8946             cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", name);
8947           else
8948             cp_pedwarn ("ANSI C++ forbids zero-size array");
8949         }
8950     }
8951
8952   /* Compute the index of the largest element in the array.  It is
8953      one less than the number of elements in the array.  */
8954   itype
8955     = fold (build_binary_op (MINUS_EXPR,
8956                              cp_convert (ssizetype, size),
8957                              cp_convert (ssizetype,
8958                                          integer_one_node)));
8959
8960   /* Check for variable-sized arrays.  We allow such things as an
8961      extension, even though they are not allowed in ANSI/ISO C++.  */
8962   if (!TREE_CONSTANT (itype))
8963     {
8964       if (pedantic)
8965         {
8966           if (name)
8967             cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
8968                         name);
8969           else
8970             cp_pedwarn ("ANSI C++ forbids variable-size array");
8971         }
8972
8973       /* Create a variable-sized array index type.  */
8974       itype = variable_size (itype);
8975     }
8976   /* Make sure that there was no overflow when creating to a signed
8977      index type.  (For example, on a 32-bit machine, an array with
8978      size 2^32 - 1 is too big.)  */
8979   else if (TREE_OVERFLOW (itype))
8980     {
8981       error ("overflow in array dimension");
8982       TREE_OVERFLOW (itype) = 0;
8983     }
8984
8985   /* Create and return the appropriate index type.  */
8986   return build_index_type (itype);
8987 }
8988
8989 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8990    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
8991    with this type.  */
8992
8993 static tree
8994 create_array_type_for_decl (name, type, size)
8995      tree name;
8996      tree type;
8997      tree size;
8998 {
8999   tree itype = NULL_TREE;
9000   const char* error_msg;
9001
9002   /* If things have already gone awry, bail now.  */
9003   if (type == error_mark_node || size == error_mark_node)
9004     return error_mark_node;
9005
9006   /* Assume that everything will go OK.  */
9007   error_msg = NULL;
9008
9009   /* There are some types which cannot be array elements.  */
9010   switch (TREE_CODE (type))
9011     {
9012     case VOID_TYPE:
9013       error_msg = "array of void";
9014       break;
9015
9016     case FUNCTION_TYPE:
9017       error_msg = "array of functions";
9018       break;
9019
9020     case REFERENCE_TYPE:
9021       error_msg = "array of references";
9022       break;
9023
9024     case OFFSET_TYPE:
9025       error_msg = "array of data members";
9026       break;
9027
9028     case METHOD_TYPE:
9029       error_msg = "array of function members";
9030       break;
9031
9032     default:
9033       break;
9034     }
9035
9036   /* If something went wrong, issue an error-message and return.  */
9037   if (error_msg)
9038     {
9039       if (name)
9040         cp_error ("declaration of `%D' as %s", name, error_msg);
9041       else
9042         cp_error ("creating %s", error_msg);
9043
9044       return error_mark_node;
9045     }
9046
9047   /* [dcl.array]
9048
9049      The constant expressions that specify the bounds of the arrays
9050      can be omitted only for the first member of the sequence.  */
9051   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9052     {
9053       cp_error ("declaration of `%D' as multidimensional array",
9054                 name);
9055       cp_error ("must have bounds for all dimensions except the first");
9056
9057       return error_mark_node;
9058     }
9059
9060   /* Figure out the index type for the array.  */
9061   if (size)
9062     itype = compute_array_index_type (name, size);
9063
9064   return build_cplus_array_type (type, itype);
9065 }
9066
9067 /* Given declspecs and a declarator,
9068    determine the name and type of the object declared
9069    and construct a ..._DECL node for it.
9070    (In one case we can return a ..._TYPE node instead.
9071     For invalid input we sometimes return 0.)
9072
9073    DECLSPECS is a chain of tree_list nodes whose value fields
9074     are the storage classes and type specifiers.
9075
9076    DECL_CONTEXT says which syntactic context this declaration is in:
9077      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9078      FUNCDEF for a function definition.  Like NORMAL but a few different
9079       error messages in each case.  Return value may be zero meaning
9080       this definition is too screwy to try to parse.
9081      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9082       handle member functions (which have FIELD context).
9083       Return value may be zero meaning this definition is too screwy to
9084       try to parse.
9085      PARM for a parameter declaration (either within a function prototype
9086       or before a function body).  Make a PARM_DECL, or return void_type_node.
9087      CATCHPARM for a parameter declaration before a catch clause.
9088      TYPENAME if for a typename (in a cast or sizeof).
9089       Don't make a DECL node; just return the ..._TYPE node.
9090      FIELD for a struct or union field; make a FIELD_DECL.
9091      BITFIELD for a field with specified width.
9092    INITIALIZED is 1 if the decl has an initializer.
9093
9094    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9095    normal attributes in TREE_PURPOSE, or NULL_TREE.
9096
9097    In the TYPENAME case, DECLARATOR is really an absolute declarator.
9098    It may also be so in the PARM case, for a prototype where the
9099    argument type is specified but not the name.
9100
9101    This function is where the complicated C meanings of `static'
9102    and `extern' are interpreted.
9103
9104    For C++, if there is any monkey business to do, the function which
9105    calls this one must do it, i.e., prepending instance variables,
9106    renaming overloaded function names, etc.
9107
9108    Note that for this C++, it is an error to define a method within a class
9109    which does not belong to that class.
9110
9111    Except in the case where SCOPE_REFs are implicitly known (such as
9112    methods within a class being redundantly qualified),
9113    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9114    (class_name::decl_name).  The caller must also deal with this.
9115
9116    If a constructor or destructor is seen, and the context is FIELD,
9117    then the type gains the attribute TREE_HAS_x.  If such a declaration
9118    is erroneous, NULL_TREE is returned.
9119
9120    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9121    function, these are the qualifiers to give to the `this' pointer. We
9122    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9123
9124    May return void_type_node if the declarator turned out to be a friend.
9125    See grokfield for details.  */
9126
9127 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
9128
9129 tree
9130 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9131      tree declspecs;
9132      tree declarator;
9133      enum decl_context decl_context;
9134      int initialized;
9135      tree attrlist;
9136 {
9137   RID_BIT_TYPE specbits;
9138   int nclasses = 0;
9139   tree spec;
9140   tree type = NULL_TREE;
9141   int longlong = 0;
9142   int constp;
9143   int restrictp;
9144   int volatilep;
9145   int type_quals;
9146   int virtualp, explicitp, friendp, inlinep, staticp;
9147   int explicit_int = 0;
9148   int explicit_char = 0;
9149   int defaulted_int = 0;
9150   tree typedef_decl = NULL_TREE;
9151   const char *name;
9152   tree typedef_type = NULL_TREE;
9153   int funcdef_flag = 0;
9154   enum tree_code innermost_code = ERROR_MARK;
9155   int bitfield = 0;
9156 #if 0
9157   /* See the code below that used this.  */
9158   tree decl_machine_attr = NULL_TREE;
9159 #endif
9160   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9161      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9162   tree init = NULL_TREE;
9163
9164   /* Keep track of what sort of function is being processed
9165      so that we can warn about default return values, or explicit
9166      return values which do not match prescribed defaults.  */
9167   enum return_types return_type = return_normal;
9168
9169   tree dname = NULL_TREE;
9170   tree ctype = current_class_type;
9171   tree ctor_return_type = NULL_TREE;
9172   enum overload_flags flags = NO_SPECIAL;
9173   tree quals = NULL_TREE;
9174   tree raises = NULL_TREE;
9175   int template_count = 0;
9176   tree in_namespace = NULL_TREE;
9177   tree inner_attrs;
9178   int ignore_attrs;
9179
9180   RIDBIT_RESET_ALL (specbits);
9181   if (decl_context == FUNCDEF)
9182     funcdef_flag = 1, decl_context = NORMAL;
9183   else if (decl_context == MEMFUNCDEF)
9184     funcdef_flag = -1, decl_context = FIELD;
9185   else if (decl_context == BITFIELD)
9186     bitfield = 1, decl_context = FIELD;
9187
9188   /* Look inside a declarator for the name being declared
9189      and get it as a string, for an error message.  */
9190   {
9191     tree *next = &declarator;
9192     register tree decl;
9193     name = NULL;
9194
9195     while (next && *next)
9196       {
9197         decl = *next;
9198         switch (TREE_CODE (decl))
9199           {
9200           case TREE_LIST:
9201             /* For attributes.  */
9202             next = &TREE_VALUE (decl);
9203             break;
9204
9205           case COND_EXPR:
9206             ctype = NULL_TREE;
9207             next = &TREE_OPERAND (decl, 0);
9208             break;
9209
9210           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9211             {
9212               tree name = TREE_OPERAND (decl, 0);
9213               tree rename = NULL_TREE;
9214
9215               my_friendly_assert (flags == NO_SPECIAL, 152);
9216               flags = DTOR_FLAG;
9217               return_type = return_dtor;
9218               if (TREE_CODE (name) == TYPE_DECL)
9219                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9220               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9221               if (ctype == NULL_TREE)
9222                 {
9223                   if (current_class_type == NULL_TREE)
9224                     {
9225                       error ("destructors must be member functions");
9226                       flags = NO_SPECIAL;
9227                     }
9228                   else
9229                     {
9230                       tree t = constructor_name (current_class_name);
9231                       if (t != name)
9232                         rename = t;
9233                     }
9234                 }
9235               else
9236                 {
9237                   tree t = constructor_name (ctype);
9238                   if (t != name)
9239                     rename = t;
9240                 }
9241
9242               if (rename)
9243                 {
9244                   cp_error ("destructor `%T' must match class name `%T'",
9245                             name, rename);
9246                   TREE_OPERAND (decl, 0) = rename;
9247                 }
9248               next = &name;
9249             }
9250             break;
9251
9252           case ADDR_EXPR:       /* C++ reference declaration */
9253             /* Fall through. */
9254           case ARRAY_REF:
9255           case INDIRECT_REF:
9256             ctype = NULL_TREE;
9257             innermost_code = TREE_CODE (decl);
9258             next = &TREE_OPERAND (decl, 0);
9259             break;
9260
9261           case CALL_EXPR:
9262             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9263               {
9264                 /* This is actually a variable declaration using
9265                    constructor syntax.  We need to call start_decl and
9266                    cp_finish_decl so we can get the variable
9267                    initialized...  */
9268
9269                 tree attributes, prefix_attributes;
9270
9271                 *next = TREE_OPERAND (decl, 0);
9272                 init = CALL_DECLARATOR_PARMS (decl);
9273
9274                 if (attrlist)
9275                   {
9276                     attributes = TREE_PURPOSE (attrlist);
9277                     prefix_attributes = TREE_VALUE (attrlist);
9278                   }
9279                 else
9280                   {
9281                     attributes = NULL_TREE;
9282                     prefix_attributes = NULL_TREE;
9283                   }
9284
9285                 decl = start_decl (declarator, declspecs, 1,
9286                                    attributes, prefix_attributes);
9287                 if (decl)
9288                   {
9289                     /* Look for __unused__ attribute */
9290                     if (TREE_USED (TREE_TYPE (decl)))
9291                       TREE_USED (decl) = 1;
9292                     finish_decl (decl, init, NULL_TREE);
9293                   }
9294                 else
9295                   cp_error ("invalid declarator");
9296                 return 0;
9297               }
9298             innermost_code = TREE_CODE (decl);
9299             if (decl_context == FIELD && ctype == NULL_TREE)
9300               ctype = current_class_type;
9301             if (ctype
9302                 && TREE_OPERAND (decl, 0)
9303                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9304                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9305                          == constructor_name_full (ctype))
9306                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9307                             == constructor_name (ctype)))))
9308               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9309             next = &TREE_OPERAND (decl, 0);
9310             decl = *next;
9311             if (ctype != NULL_TREE
9312                 && decl != NULL_TREE && flags != DTOR_FLAG
9313                 && decl == constructor_name (ctype))
9314               {
9315                 return_type = return_ctor;
9316                 ctor_return_type = ctype;
9317               }
9318             ctype = NULL_TREE;
9319             break;
9320
9321           case TEMPLATE_ID_EXPR:
9322               {
9323                 tree fns = TREE_OPERAND (decl, 0);
9324
9325                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9326                   fns = TREE_OPERAND (fns, 0);
9327
9328                 dname = fns;
9329                 if (TREE_CODE (dname) == COMPONENT_REF)
9330                   dname = TREE_OPERAND (dname, 1);
9331                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9332                   {
9333                     my_friendly_assert (is_overloaded_fn (dname),
9334                                         19990331);
9335                     dname = DECL_NAME (get_first_fn (dname));
9336                   }
9337               }
9338           /* Fall through. */
9339
9340           case IDENTIFIER_NODE:
9341             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9342               dname = decl;
9343
9344             next = 0;
9345
9346             if (is_rid (dname))
9347               {
9348                 cp_error ("declarator-id missing; using reserved word `%D'",
9349                           dname);
9350                 name = IDENTIFIER_POINTER (dname);
9351               }
9352             if (! IDENTIFIER_OPNAME_P (dname)
9353                 /* GNU/Linux headers use '__op'.  Arrgh.  */
9354                 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
9355               name = IDENTIFIER_POINTER (dname);
9356             else
9357               {
9358                 if (IDENTIFIER_TYPENAME_P (dname))
9359                   {
9360                     my_friendly_assert (flags == NO_SPECIAL, 154);
9361                     flags = TYPENAME_FLAG;
9362                     ctor_return_type = TREE_TYPE (dname);
9363                     return_type = return_conversion;
9364                   }
9365                 name = operator_name_string (dname);
9366               }
9367             break;
9368
9369             /* C++ extension */
9370           case SCOPE_REF:
9371             {
9372               /* Perform error checking, and decide on a ctype.  */
9373               tree cname = TREE_OPERAND (decl, 0);
9374               if (cname == NULL_TREE)
9375                 ctype = NULL_TREE;
9376               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9377                 {
9378                   ctype = NULL_TREE;
9379                   in_namespace = TREE_OPERAND (decl, 0);
9380                   TREE_OPERAND (decl, 0) = NULL_TREE;
9381                 }
9382               else if (! is_aggr_type (cname, 1))
9383                 TREE_OPERAND (decl, 0) = NULL_TREE;
9384               /* Must test TREE_OPERAND (decl, 1), in case user gives
9385                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9386               else if (TREE_OPERAND (decl, 1)
9387                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9388                 ctype = cname;
9389               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9390                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9391                 {
9392                   cp_error ("`%T::%D' is not a valid declarator", cname,
9393                             TREE_OPERAND (decl, 1));
9394                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9395                             cname, TREE_OPERAND (decl, 1));
9396                   return void_type_node;
9397                 }
9398               else if (ctype == NULL_TREE)
9399                 ctype = cname;
9400               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9401                 TREE_OPERAND (decl, 0) = ctype;
9402               else
9403                 {
9404                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9405                     {
9406                       cp_error ("type `%T' is not derived from type `%T'",
9407                                 cname, ctype);
9408                       TREE_OPERAND (decl, 0) = NULL_TREE;
9409                     }
9410                   else
9411                     ctype = cname;
9412                 }
9413
9414               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9415                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9416                        == constructor_name_full (ctype))
9417                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9418                           == constructor_name (ctype))))
9419                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9420               next = &TREE_OPERAND (decl, 1);
9421               decl = *next;
9422               if (ctype)
9423                 {
9424                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9425                       && constructor_name (ctype) == decl)
9426                     {
9427                       return_type = return_ctor;
9428                       ctor_return_type = ctype;
9429                     }
9430                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9431                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9432                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9433                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9434                     {
9435                       return_type = return_dtor;
9436                       ctor_return_type = ctype;
9437                       flags = DTOR_FLAG;
9438                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9439                       next = &TREE_OPERAND (decl, 0);
9440                     }
9441                 }
9442             }
9443             break;
9444
9445           case ERROR_MARK:
9446             next = 0;
9447             break;
9448
9449           case TYPE_DECL:
9450             /* Parse error puts this typespec where
9451                a declarator should go.  */
9452             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9453             if (TREE_TYPE (decl) == current_class_type)
9454               cp_error ("  perhaps you want `%T' for a constructor",
9455                         current_class_name);
9456             dname = DECL_NAME (decl);
9457             name = IDENTIFIER_POINTER (dname);
9458
9459             /* Avoid giving two errors for this.  */
9460             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9461
9462             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9463             *next = dname;
9464             next = 0;
9465             break;
9466
9467           default:
9468             cp_compiler_error ("`%D' as declarator", decl);
9469             return 0; /* We used to do a 155 abort here.  */
9470           }
9471       }
9472   }
9473
9474   /* A function definition's declarator must have the form of
9475      a function declarator.  */
9476
9477   if (funcdef_flag && innermost_code != CALL_EXPR)
9478     return 0;
9479
9480   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9481       && innermost_code != CALL_EXPR
9482       && ! (ctype && declspecs == NULL_TREE))
9483     {
9484       cp_error ("declaration of `%D' as non-function", dname);
9485       return void_type_node;
9486     }
9487
9488   /* Anything declared one level down from the top level
9489      must be one of the parameters of a function
9490      (because the body is at least two levels down).  */
9491
9492   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9493      by not allowing C++ class definitions to specify their parameters
9494      with xdecls (must be spec.d in the parmlist).
9495
9496      Since we now wait to push a class scope until we are sure that
9497      we are in a legitimate method context, we must set oldcname
9498      explicitly (since current_class_name is not yet alive).
9499
9500      We also want to avoid calling this a PARM if it is in a namespace.  */
9501
9502   if (decl_context == NORMAL && !toplevel_bindings_p ())
9503     {
9504       struct binding_level *b = current_binding_level;
9505       current_binding_level = b->level_chain;
9506       if (current_binding_level != 0 && toplevel_bindings_p ())
9507         decl_context = PARM;
9508       current_binding_level = b;
9509     }
9510
9511   if (name == NULL)
9512     name = decl_context == PARM ? "parameter" : "type name";
9513
9514   /* Look through the decl specs and record which ones appear.
9515      Some typespecs are defined as built-in typenames.
9516      Others, the ones that are modifiers of other types,
9517      are represented by bits in SPECBITS: set the bits for
9518      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9519
9520      If there is a typedef name or a type, store the type in TYPE.
9521      This includes builtin typedefs such as `int'.
9522
9523      Set EXPLICIT_INT if the type is `int' or `char' and did not
9524      come from a user typedef.
9525
9526      Set LONGLONG if `long' is mentioned twice.
9527
9528      For C++, constructors and destructors have their own fast treatment.  */
9529
9530   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9531     {
9532       register int i;
9533       register tree id;
9534
9535       /* Certain parse errors slip through.  For example,
9536          `int class;' is not caught by the parser. Try
9537          weakly to recover here.  */
9538       if (TREE_CODE (spec) != TREE_LIST)
9539         return 0;
9540
9541       id = TREE_VALUE (spec);
9542
9543       if (TREE_CODE (id) == IDENTIFIER_NODE)
9544         {
9545           if (id == ridpointers[(int) RID_INT]
9546               || id == ridpointers[(int) RID_CHAR]
9547               || id == ridpointers[(int) RID_BOOL]
9548               || id == ridpointers[(int) RID_WCHAR])
9549             {
9550               if (type)
9551                 {
9552                   if (id == ridpointers[(int) RID_BOOL])
9553                     error ("`bool' is now a keyword");
9554                   else
9555                     cp_error ("extraneous `%T' ignored", id);
9556                 }
9557               else
9558                 {
9559                   if (id == ridpointers[(int) RID_INT])
9560                     explicit_int = 1;
9561                   else if (id == ridpointers[(int) RID_CHAR])
9562                     explicit_char = 1;
9563                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9564                 }
9565               goto found;
9566             }
9567           /* C++ aggregate types.  */
9568           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9569             {
9570               if (type)
9571                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9572               else
9573                 type = IDENTIFIER_TYPE_VALUE (id);
9574               goto found;
9575             }
9576
9577           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9578             {
9579               if (ridpointers[i] == id)
9580                 {
9581                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9582                     {
9583                       if (pedantic && ! in_system_header && warn_long_long)
9584                         pedwarn ("ANSI C++ does not support `long long'");
9585                       if (longlong)
9586                         error ("`long long long' is too long for GCC");
9587                       else
9588                         longlong = 1;
9589                     }
9590                   else if (RIDBIT_SETP (i, specbits))
9591                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9592                   RIDBIT_SET (i, specbits);
9593                   goto found;
9594                 }
9595             }
9596         }
9597       /* C++ aggregate types.  */
9598       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9599         {
9600           if (type)
9601             cp_error ("multiple declarations `%T' and `%T'", type,
9602                       TREE_TYPE (id));
9603           else
9604             {
9605               type = TREE_TYPE (id);
9606               TREE_VALUE (spec) = type;
9607             }
9608           goto found;
9609         }
9610       if (type)
9611         error ("two or more data types in declaration of `%s'", name);
9612       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9613         {
9614           register tree t = lookup_name (id, 1);
9615           if (!t || TREE_CODE (t) != TYPE_DECL)
9616             error ("`%s' fails to be a typedef or built in type",
9617                    IDENTIFIER_POINTER (id));
9618           else
9619             {
9620               type = TREE_TYPE (t);
9621 #if 0
9622               /* See the code below that used this.  */
9623               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9624 #endif
9625               typedef_decl = t;
9626             }
9627         }
9628       else if (id != error_mark_node)
9629         /* Can't change CLASS nodes into RECORD nodes here!  */
9630         type = id;
9631
9632     found: ;
9633     }
9634
9635   typedef_type = type;
9636
9637   /* No type at all: default to `int', and set DEFAULTED_INT
9638      because it was not a user-defined typedef.  */
9639
9640   if (type == NULL_TREE
9641       && (RIDBIT_SETP (RID_SIGNED, specbits)
9642           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9643           || RIDBIT_SETP (RID_LONG, specbits)
9644           || RIDBIT_SETP (RID_SHORT, specbits)))
9645     {
9646       /* These imply 'int'.  */
9647       type = integer_type_node;
9648       defaulted_int = 1;
9649     }
9650
9651   if (type == NULL_TREE)
9652     {
9653       explicit_int = -1;
9654       if (return_type == return_dtor)
9655         type = void_type_node;
9656       else if (return_type == return_ctor)
9657         type = build_pointer_type (ctor_return_type);
9658       else if (return_type == return_conversion)
9659         type = ctor_return_type;
9660       else
9661         {
9662           /* We handle `main' specially here, because 'main () { }' is so
9663              common.  With no options, it is allowed.  With -Wreturn-type,
9664              it is a warning.  It is only an error with -pedantic-errors.  */
9665           int is_main = (funcdef_flag
9666                          && MAIN_NAME_P (dname)
9667                          && ctype == NULL_TREE
9668                          && in_namespace == NULL_TREE
9669                          && current_namespace == global_namespace);
9670
9671           if (in_system_header || flag_ms_extensions)
9672             /* Allow it, sigh.  */;
9673           else if (pedantic || ! is_main)
9674             cp_pedwarn ("ANSI C++ forbids declaration of `%s' with no type",
9675                         name);
9676           else if (warn_return_type)
9677             cp_warning ("ANSI C++ forbids declaration of `%s' with no type",
9678                         name);
9679
9680           type = integer_type_node;
9681         }
9682     }
9683   else if (return_type == return_dtor)
9684     {
9685       error ("return type specification for destructor invalid");
9686       type = void_type_node;
9687     }
9688   else if (return_type == return_ctor)
9689     {
9690       error ("return type specification for constructor invalid");
9691       type = build_pointer_type (ctor_return_type);
9692     }
9693   else if (return_type == return_conversion)
9694     {
9695       if (!same_type_p (type, ctor_return_type))
9696         cp_error ("operator `%T' declared to return `%T'",
9697                   ctor_return_type, type);
9698       else
9699         cp_pedwarn ("return type specified for `operator %T'",
9700                     ctor_return_type);
9701
9702       type = ctor_return_type;
9703     }
9704
9705   ctype = NULL_TREE;
9706
9707   /* Now process the modifiers that were specified
9708      and check for invalid combinations.  */
9709
9710   /* Long double is a special combination.  */
9711
9712   if (RIDBIT_SETP (RID_LONG, specbits)
9713       && TYPE_MAIN_VARIANT (type) == double_type_node)
9714     {
9715       RIDBIT_RESET (RID_LONG, specbits);
9716       type = build_qualified_type (long_double_type_node,
9717                                    CP_TYPE_QUALS (type));
9718     }
9719
9720   /* Check all other uses of type modifiers.  */
9721
9722   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9723       || RIDBIT_SETP (RID_SIGNED, specbits)
9724       || RIDBIT_SETP (RID_LONG, specbits)
9725       || RIDBIT_SETP (RID_SHORT, specbits))
9726     {
9727       int ok = 0;
9728
9729       if (TREE_CODE (type) == REAL_TYPE)
9730         error ("short, signed or unsigned invalid for `%s'", name);
9731       else if (TREE_CODE (type) != INTEGER_TYPE)
9732         error ("long, short, signed or unsigned invalid for `%s'", name);
9733       else if (RIDBIT_SETP (RID_LONG, specbits)
9734                && RIDBIT_SETP (RID_SHORT, specbits))
9735         error ("long and short specified together for `%s'", name);
9736       else if ((RIDBIT_SETP (RID_LONG, specbits)
9737                 || RIDBIT_SETP (RID_SHORT, specbits))
9738                && explicit_char)
9739         error ("long or short specified with char for `%s'", name);
9740       else if ((RIDBIT_SETP (RID_LONG, specbits)
9741                 || RIDBIT_SETP (RID_SHORT, specbits))
9742                && TREE_CODE (type) == REAL_TYPE)
9743         error ("long or short specified with floating type for `%s'", name);
9744       else if (RIDBIT_SETP (RID_SIGNED, specbits)
9745                && RIDBIT_SETP (RID_UNSIGNED, specbits))
9746         error ("signed and unsigned given together for `%s'", name);
9747       else
9748         {
9749           ok = 1;
9750           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
9751             {
9752               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9753                        name);
9754               if (flag_pedantic_errors)
9755                 ok = 0;
9756             }
9757         }
9758
9759       /* Discard the type modifiers if they are invalid.  */
9760       if (! ok)
9761         {
9762           RIDBIT_RESET (RID_UNSIGNED, specbits);
9763           RIDBIT_RESET (RID_SIGNED, specbits);
9764           RIDBIT_RESET (RID_LONG, specbits);
9765           RIDBIT_RESET (RID_SHORT, specbits);
9766           longlong = 0;
9767         }
9768     }
9769
9770   if (RIDBIT_SETP (RID_COMPLEX, specbits)
9771       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9772     {
9773       error ("complex invalid for `%s'", name);
9774       RIDBIT_RESET (RID_COMPLEX, specbits);
9775     }
9776
9777   /* Decide whether an integer type is signed or not.
9778      Optionally treat bitfields as signed by default.  */
9779   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9780       /* [class.bit]
9781
9782          It is implementation-defined whether a plain (neither
9783          explicitly signed or unsigned) char, short, int, or long
9784          bit-field is signed or unsigned.
9785
9786          Naturally, we extend this to long long as well.  Note that
9787          this does not include wchar_t.  */
9788       || (bitfield && !flag_signed_bitfields
9789           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
9790           /* A typedef for plain `int' without `signed' can be
9791              controlled just like plain `int', but a typedef for
9792              `signed int' cannot be so controlled.  */
9793           && !(typedef_decl
9794                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
9795           && (TREE_CODE (type) == INTEGER_TYPE
9796               || TREE_CODE (type) == CHAR_TYPE)
9797           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
9798     {
9799       if (longlong)
9800         type = long_long_unsigned_type_node;
9801       else if (RIDBIT_SETP (RID_LONG, specbits))
9802         type = long_unsigned_type_node;
9803       else if (RIDBIT_SETP (RID_SHORT, specbits))
9804         type = short_unsigned_type_node;
9805       else if (type == char_type_node)
9806         type = unsigned_char_type_node;
9807       else if (typedef_decl)
9808         type = unsigned_type (type);
9809       else
9810         type = unsigned_type_node;
9811     }
9812   else if (RIDBIT_SETP (RID_SIGNED, specbits)
9813            && type == char_type_node)
9814     type = signed_char_type_node;
9815   else if (longlong)
9816     type = long_long_integer_type_node;
9817   else if (RIDBIT_SETP (RID_LONG, specbits))
9818     type = long_integer_type_node;
9819   else if (RIDBIT_SETP (RID_SHORT, specbits))
9820     type = short_integer_type_node;
9821
9822   if (RIDBIT_SETP (RID_COMPLEX, specbits))
9823     {
9824       /* If we just have "complex", it is equivalent to
9825          "complex double", but if any modifiers at all are specified it is
9826          the complex form of TYPE.  E.g, "complex short" is
9827          "complex short int".  */
9828
9829       if (defaulted_int && ! longlong
9830           && ! (RIDBIT_SETP (RID_LONG, specbits)
9831                 || RIDBIT_SETP (RID_SHORT, specbits)
9832                 || RIDBIT_SETP (RID_SIGNED, specbits)
9833                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
9834         type = complex_double_type_node;
9835       else if (type == integer_type_node)
9836         type = complex_integer_type_node;
9837       else if (type == float_type_node)
9838         type = complex_float_type_node;
9839       else if (type == double_type_node)
9840         type = complex_double_type_node;
9841       else if (type == long_double_type_node)
9842         type = complex_long_double_type_node;
9843       else
9844         type = build_complex_type (type);
9845     }
9846
9847   if (return_type == return_conversion
9848       && (RIDBIT_SETP (RID_CONST, specbits)
9849           || RIDBIT_SETP (RID_VOLATILE, specbits)
9850           || RIDBIT_SETP (RID_RESTRICT, specbits)))
9851     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9852               ctor_return_type);
9853
9854   /* Set CONSTP if this declaration is `const', whether by
9855      explicit specification or via a typedef.
9856      Likewise for VOLATILEP.  */
9857
9858   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
9859   restrictp =
9860     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
9861   volatilep =
9862     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
9863   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
9864                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
9865                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
9866   type = cp_build_qualified_type (type, type_quals);
9867   staticp = 0;
9868   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
9869   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
9870   RIDBIT_RESET (RID_VIRTUAL, specbits);
9871   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
9872   RIDBIT_RESET (RID_EXPLICIT, specbits);
9873
9874   if (RIDBIT_SETP (RID_STATIC, specbits))
9875     staticp = 1 + (decl_context == FIELD);
9876
9877   if (virtualp && staticp == 2)
9878     {
9879       cp_error ("member `%D' cannot be declared both virtual and static",
9880                 dname);
9881       staticp = 0;
9882     }
9883   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
9884   RIDBIT_RESET (RID_FRIEND, specbits);
9885
9886   /* Warn if two storage classes are given. Default to `auto'.  */
9887
9888   if (RIDBIT_ANY_SET (specbits))
9889     {
9890       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
9891       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
9892       if (decl_context == PARM && nclasses > 0)
9893         error ("storage class specifiers invalid in parameter declarations");
9894       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9895         {
9896           if (decl_context == PARM)
9897             error ("typedef declaration invalid in parameter declaration");
9898           nclasses++;
9899         }
9900       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
9901       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
9902     }
9903
9904   /* Give error if `virtual' is used outside of class declaration.  */
9905   if (virtualp
9906       && (current_class_name == NULL_TREE || decl_context != FIELD))
9907     {
9908       error ("virtual outside class declaration");
9909       virtualp = 0;
9910     }
9911
9912   /* Static anonymous unions are dealt with here.  */
9913   if (staticp && decl_context == TYPENAME
9914       && TREE_CODE (declspecs) == TREE_LIST
9915       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
9916     decl_context = FIELD;
9917
9918   /* Warn about storage classes that are invalid for certain
9919      kinds of declarations (parameters, typenames, etc.).  */
9920
9921   if (nclasses > 1)
9922     error ("multiple storage classes in declaration of `%s'", name);
9923   else if (decl_context != NORMAL && nclasses > 0)
9924     {
9925       if ((decl_context == PARM || decl_context == CATCHPARM)
9926           && (RIDBIT_SETP (RID_REGISTER, specbits)
9927               || RIDBIT_SETP (RID_AUTO, specbits)))
9928         ;
9929       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9930         ;
9931       else if (decl_context == FIELD
9932                /* C++ allows static class elements  */
9933                && RIDBIT_SETP (RID_STATIC, specbits))
9934         /* C++ also allows inlines and signed and unsigned elements,
9935            but in those cases we don't come in here.  */
9936         ;
9937       else
9938         {
9939           if (decl_context == FIELD)
9940             {
9941               tree tmp = NULL_TREE;
9942               register int op = 0;
9943
9944               if (declarator)
9945                 {
9946                   /* Avoid trying to get an operand off an identifier node.  */
9947                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
9948                     tmp = declarator;
9949                   else
9950                     tmp = TREE_OPERAND (declarator, 0);
9951                   op = IDENTIFIER_OPNAME_P (tmp);
9952                 }
9953               error ("storage class specified for %s `%s'",
9954                      op ? "member operator" : "field",
9955                      op ? operator_name_string (tmp) : name);
9956             }
9957           else
9958             {
9959               if (decl_context == PARM || decl_context == CATCHPARM)
9960                 error ("storage class specified for parameter `%s'", name);
9961               else
9962                 error ("storage class specified for typename");
9963             }
9964           RIDBIT_RESET (RID_REGISTER, specbits);
9965           RIDBIT_RESET (RID_AUTO, specbits);
9966           RIDBIT_RESET (RID_EXTERN, specbits);
9967         }
9968     }
9969   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
9970     {
9971       if (toplevel_bindings_p ())
9972         {
9973           /* It's common practice (and completely valid) to have a const
9974              be initialized and declared extern.  */
9975           if (!(type_quals & TYPE_QUAL_CONST))
9976             warning ("`%s' initialized and declared `extern'", name);
9977         }
9978       else
9979         error ("`%s' has both `extern' and initializer", name);
9980     }
9981   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
9982            && ! toplevel_bindings_p ())
9983     error ("nested function `%s' declared `extern'", name);
9984   else if (toplevel_bindings_p ())
9985     {
9986       if (RIDBIT_SETP (RID_AUTO, specbits))
9987         error ("top-level declaration of `%s' specifies `auto'", name);
9988     }
9989
9990   if (nclasses > 0 && friendp)
9991     error ("storage class specifiers invalid in friend function declarations");
9992
9993   /* Now figure out the structure of the declarator proper.
9994      Descend through it, creating more complex types, until we reach
9995      the declared identifier (or NULL_TREE, in an absolute declarator).  */
9996
9997   inner_attrs = NULL_TREE;
9998   ignore_attrs = 0;
9999
10000   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10001          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10002     {
10003       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10004          an INDIRECT_REF (for *...),
10005          a CALL_EXPR (for ...(...)),
10006          an identifier (for the name being declared)
10007          or a null pointer (for the place in an absolute declarator
10008          where the name was omitted).
10009          For the last two cases, we have just exited the loop.
10010
10011          For C++ it could also be
10012          a SCOPE_REF (for class :: ...).  In this case, we have converted
10013          sensible names to types, and those are the values we use to
10014          qualify the member name.
10015          an ADDR_EXPR (for &...),
10016          a BIT_NOT_EXPR (for destructors)
10017
10018          At this point, TYPE is the type of elements of an array,
10019          or for a function to return, or for a pointer to point to.
10020          After this sequence of ifs, TYPE is the type of the
10021          array or function or pointer, and DECLARATOR has had its
10022          outermost layer removed.  */
10023
10024       if (type == error_mark_node)
10025         {
10026           if (TREE_CODE (declarator) == SCOPE_REF)
10027             declarator = TREE_OPERAND (declarator, 1);
10028           else
10029             declarator = TREE_OPERAND (declarator, 0);
10030           continue;
10031         }
10032       if (quals != NULL_TREE
10033           && (declarator == NULL_TREE
10034               || TREE_CODE (declarator) != SCOPE_REF))
10035         {
10036           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10037             ctype = TYPE_METHOD_BASETYPE (type);
10038           if (ctype != NULL_TREE)
10039             {
10040               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10041               grok_method_quals (ctype, dummy, quals);
10042               type = TREE_TYPE (dummy);
10043               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10044               quals = NULL_TREE;
10045             }
10046         }
10047
10048       /* See the comment for the TREE_LIST case, below.  */
10049       if (ignore_attrs)
10050         ignore_attrs = 0;
10051       else if (inner_attrs)
10052         {
10053           decl_attributes (type, inner_attrs, NULL_TREE);
10054           inner_attrs = NULL_TREE;
10055         }
10056
10057       switch (TREE_CODE (declarator))
10058         {
10059         case TREE_LIST:
10060           {
10061             /* We encode a declarator with embedded attributes using
10062                a TREE_LIST.  The attributes apply to the declarator
10063                directly inside them, so we have to skip an iteration
10064                before applying them to the type.  If the declarator just
10065                inside is the declarator-id, we apply the attrs to the
10066                decl itself.  */
10067             inner_attrs = TREE_PURPOSE (declarator);
10068             ignore_attrs = 1;
10069             declarator = TREE_VALUE (declarator);
10070           }
10071           break;
10072
10073         case ARRAY_REF:
10074           {
10075             register tree size;
10076
10077             size = TREE_OPERAND (declarator, 1);
10078
10079             /* VC++ spells a zero-sized array with [].  */
10080             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10081                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10082               size = integer_zero_node;
10083
10084             declarator = TREE_OPERAND (declarator, 0);
10085
10086             type = create_array_type_for_decl (dname, type, size);
10087             ctype = NULL_TREE;
10088           }
10089           break;
10090
10091         case CALL_EXPR:
10092           {
10093             tree arg_types;
10094             int funcdecl_p;
10095             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10096             tree inner_decl = TREE_OPERAND (declarator, 0);
10097
10098             /* Declaring a function type.
10099                Make sure we have a valid type for the function to return.  */
10100
10101             /* We now know that the TYPE_QUALS don't apply to the
10102                decl, but to its return type.  */
10103             type_quals = TYPE_UNQUALIFIED;
10104
10105             /* Warn about some types functions can't return.  */
10106
10107             if (TREE_CODE (type) == FUNCTION_TYPE)
10108               {
10109                 error ("`%s' declared as function returning a function", name);
10110                 type = integer_type_node;
10111               }
10112             if (TREE_CODE (type) == ARRAY_TYPE)
10113               {
10114                 error ("`%s' declared as function returning an array", name);
10115                 type = integer_type_node;
10116               }
10117
10118             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10119               inner_decl = TREE_OPERAND (inner_decl, 1);
10120
10121             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10122               inner_decl = dname;
10123
10124             /* Pick up type qualifiers which should be applied to `this'.  */
10125             quals = CALL_DECLARATOR_QUALS (declarator);
10126
10127             /* Pick up the exception specifications.  */
10128             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10129
10130             /* Say it's a definition only for the CALL_EXPR
10131                closest to the identifier.  */
10132             funcdecl_p
10133               = inner_decl
10134               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10135                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10136                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10137
10138             if (ctype == NULL_TREE
10139                 && decl_context == FIELD
10140                 && funcdecl_p
10141                 && (friendp == 0 || dname == current_class_name))
10142               ctype = current_class_type;
10143
10144             if (ctype && return_type == return_conversion)
10145               TYPE_HAS_CONVERSION (ctype) = 1;
10146             if (ctype && constructor_name (ctype) == dname)
10147               {
10148                 /* We are within a class's scope. If our declarator name
10149                    is the same as the class name, and we are defining
10150                    a function, then it is a constructor/destructor, and
10151                    therefore returns a void type.  */
10152
10153                 if (flags == DTOR_FLAG)
10154                   {
10155                     /* ANSI C++ June 5 1992 WP 12.4.1.  A destructor may
10156                        not be declared const or volatile.  A destructor
10157                        may not be static.  */
10158                     if (staticp == 2)
10159                       error ("destructor cannot be static member function");
10160                     if (quals)
10161                       {
10162                         cp_error ("destructors may not be `%s'",
10163                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10164                         quals = NULL_TREE;
10165                       }
10166                     if (decl_context == FIELD)
10167                       {
10168                         if (! member_function_or_else (ctype, current_class_type,
10169                                                        "destructor for alien class `%s' cannot be a member"))
10170                           return void_type_node;
10171                       }
10172                   }
10173                 else            /* It's a constructor.  */
10174                   {
10175                     if (explicitp == 1)
10176                       explicitp = 2;
10177                     /* ANSI C++ June 5 1992 WP 12.1.2.  A constructor may
10178                        not be declared const or volatile.  A constructor may
10179                        not be virtual.  A constructor may not be static.  */
10180                     if (staticp == 2)
10181                       error ("constructor cannot be static member function");
10182                     if (virtualp)
10183                       {
10184                         pedwarn ("constructors cannot be declared virtual");
10185                         virtualp = 0;
10186                       }
10187                     if (quals)
10188                       {
10189                         cp_error ("constructors may not be `%s'",
10190                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10191                         quals = NULL_TREE;
10192                       }
10193                     {
10194                       RID_BIT_TYPE tmp_bits;
10195                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10196                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10197                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10198                       if (RIDBIT_ANY_SET (tmp_bits))
10199                         error ("return value type specifier for constructor ignored");
10200                     }
10201                     type = build_pointer_type (ctype);
10202                     if (decl_context == FIELD)
10203                       {
10204                         if (! member_function_or_else (ctype, current_class_type,
10205                                                        "constructor for alien class `%s' cannot be member"))
10206                           return void_type_node;
10207                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10208                         if (return_type != return_ctor)
10209                           return NULL_TREE;
10210                       }
10211                   }
10212                 if (decl_context == FIELD)
10213                   staticp = 0;
10214               }
10215             else if (friendp)
10216               {
10217                 if (initialized)
10218                   error ("can't initialize friend function `%s'", name);
10219                 if (virtualp)
10220                   {
10221                     /* Cannot be both friend and virtual.  */
10222                     error ("virtual functions cannot be friends");
10223                     RIDBIT_RESET (RID_FRIEND, specbits);
10224                     friendp = 0;
10225                   }
10226                 if (decl_context == NORMAL)
10227                   error ("friend declaration not in class definition");
10228                 if (current_function_decl && funcdef_flag)
10229                   cp_error ("can't define friend function `%s' in a local class definition",
10230                             name);
10231               }
10232
10233             /* Construct the function type and go to the next
10234                inner layer of declarator.  */
10235
10236             declarator = TREE_OPERAND (declarator, 0);
10237
10238             /* FIXME: This is where default args should be fully
10239                processed.  */
10240
10241             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10242
10243             if (declarator && flags == DTOR_FLAG)
10244               {
10245                 /* A destructor declared in the body of a class will
10246                    be represented as a BIT_NOT_EXPR.  But, we just
10247                    want the underlying IDENTIFIER.  */
10248                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10249                   declarator = TREE_OPERAND (declarator, 0);
10250
10251                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10252                   arg_types = void_list_node;
10253                 else if (arg_types == NULL_TREE
10254                          || arg_types != void_list_node)
10255                   {
10256                     cp_error ("destructors may not have parameters");
10257                     arg_types = void_list_node;
10258                     last_function_parms = NULL_TREE;
10259                   }
10260               }
10261
10262             /* ANSI says that `const int foo ();'
10263                does not make the function foo const.  */
10264             type = build_function_type (type, arg_types);
10265
10266             {
10267               tree t;
10268               for (t = arg_types; t; t = TREE_CHAIN (t))
10269                 if (TREE_PURPOSE (t)
10270                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10271                   {
10272                     add_defarg_fn (type);
10273                     break;
10274                   }
10275             }
10276           }
10277           break;
10278
10279         case ADDR_EXPR:
10280         case INDIRECT_REF:
10281           /* Filter out pointers-to-references and references-to-references.
10282              We can get these if a TYPE_DECL is used.  */
10283
10284           if (TREE_CODE (type) == REFERENCE_TYPE)
10285             {
10286               error ("cannot declare %s to references",
10287                      TREE_CODE (declarator) == ADDR_EXPR
10288                      ? "references" : "pointers");
10289               declarator = TREE_OPERAND (declarator, 0);
10290               continue;
10291             }
10292
10293           if (TREE_CODE (type) == OFFSET_TYPE
10294               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10295                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10296             {
10297               cp_error ("cannot declare pointer to `%#T' member",
10298                         TREE_TYPE (type));
10299               type = TREE_TYPE (type);
10300             }
10301
10302           /* Merge any constancy or volatility into the target type
10303              for the pointer.  */
10304
10305           /* We now know that the TYPE_QUALS don't apply to the decl,
10306              but to the target of the pointer.  */
10307           type_quals = TYPE_UNQUALIFIED;
10308
10309           if (TREE_CODE (declarator) == ADDR_EXPR)
10310             {
10311               if (TREE_CODE (type) == VOID_TYPE)
10312                 error ("invalid type: `void &'");
10313               else
10314                 type = build_reference_type (type);
10315             }
10316           else if (TREE_CODE (type) == METHOD_TYPE)
10317             type = build_ptrmemfunc_type (build_pointer_type (type));
10318           else
10319             type = build_pointer_type (type);
10320
10321           /* Process a list of type modifier keywords (such as
10322              const or volatile) that were given inside the `*' or `&'.  */
10323
10324           if (TREE_TYPE (declarator))
10325             {
10326               register tree typemodlist;
10327               int erred = 0;
10328
10329               constp = 0;
10330               volatilep = 0;
10331               restrictp = 0;
10332               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10333                    typemodlist = TREE_CHAIN (typemodlist))
10334                 {
10335                   tree qualifier = TREE_VALUE (typemodlist);
10336
10337                   if (qualifier == ridpointers[(int) RID_CONST])
10338                     constp++;
10339                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10340                     volatilep++;
10341                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10342                     restrictp++;
10343                   else if (!erred)
10344                     {
10345                       erred = 1;
10346                       error ("invalid type modifier within pointer declarator");
10347                     }
10348                 }
10349               if (constp > 1)
10350                 pedwarn ("duplicate `const'");
10351               if (volatilep > 1)
10352                 pedwarn ("duplicate `volatile'");
10353               if (restrictp > 1)
10354                 pedwarn ("duplicate `restrict'");
10355
10356               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10357                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10358                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10359               if (TREE_CODE (declarator) == ADDR_EXPR
10360                   && (constp || volatilep))
10361                 {
10362                   if (constp)
10363                     pedwarn ("discarding `const' applied to a reference");
10364                   if (volatilep)
10365                     pedwarn ("discarding `volatile' applied to a reference");
10366                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10367                 }
10368               type = cp_build_qualified_type (type, type_quals);
10369             }
10370           declarator = TREE_OPERAND (declarator, 0);
10371           ctype = NULL_TREE;
10372           break;
10373
10374         case SCOPE_REF:
10375           {
10376             /* We have converted type names to NULL_TREE if the
10377                name was bogus, or to a _TYPE node, if not.
10378
10379                The variable CTYPE holds the type we will ultimately
10380                resolve to.  The code here just needs to build
10381                up appropriate member types.  */
10382             tree sname = TREE_OPERAND (declarator, 1);
10383             tree t;
10384
10385             /* Destructors can have their visibilities changed as well.  */
10386             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10387               sname = TREE_OPERAND (sname, 0);
10388
10389             if (TREE_COMPLEXITY (declarator) == 0)
10390               /* This needs to be here, in case we are called
10391                  multiple times.  */ ;
10392             else if (TREE_COMPLEXITY (declarator) == -1)
10393               /* Namespace member. */
10394               pop_decl_namespace ();
10395             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10396               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10397             else if (! IS_AGGR_TYPE_CODE
10398                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10399               ;
10400             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10401               {
10402                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10403                    that refer to ctype.  They couldn't be resolved earlier
10404                    because we hadn't pushed into the class yet.
10405                    Example: resolve 'B<T>::type' in
10406                    'B<typename B<T>::type> B<T>::f () { }'.  */
10407                 if (current_template_parms
10408                     && uses_template_parms (type)
10409                     && uses_template_parms (current_class_type))
10410                   {
10411                     tree args = current_template_args ();
10412                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10413                   }
10414
10415                 /* This pop_nested_class corresponds to the
10416                    push_nested_class used to push into class scope for
10417                    parsing the argument list of a function decl, in
10418                    qualified_id.  */
10419                 pop_nested_class ();
10420                 TREE_COMPLEXITY (declarator) = current_class_depth;
10421               }
10422             else
10423               my_friendly_abort (16);
10424
10425             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10426               {
10427                 /* We had a reference to a global decl, or
10428                    perhaps we were given a non-aggregate typedef,
10429                    in which case we cleared this out, and should just
10430                    keep going as though it wasn't there.  */
10431                 declarator = sname;
10432                 continue;
10433               }
10434             ctype = TREE_OPERAND (declarator, 0);
10435
10436             t = ctype;
10437             while (t != NULL_TREE && CLASS_TYPE_P (t))
10438               {
10439                 if (CLASSTYPE_TEMPLATE_INFO (t) &&
10440                     !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
10441                   template_count += 1;
10442                 t = TYPE_MAIN_DECL (t);
10443                 if (DECL_LANG_SPECIFIC (t))
10444                   t = DECL_CLASS_CONTEXT (t);
10445                 else
10446                   t = NULL_TREE;
10447               }
10448
10449             if (sname == NULL_TREE)
10450               goto done_scoping;
10451
10452             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10453               {
10454                 /* This is the `standard' use of the scoping operator:
10455                    basetype :: member .  */
10456
10457                 if (ctype == current_class_type)
10458                   {
10459                     /* class A {
10460                          void A::f ();
10461                        };
10462
10463                        Is this ill-formed?  */
10464
10465                     if (pedantic)
10466                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10467                                   ctype, name);
10468                   }
10469                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10470                   {
10471                     if (current_class_type == NULL_TREE
10472                         || friendp)
10473                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10474                                                       TYPE_ARG_TYPES (type));
10475                     else
10476                       {
10477                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10478                                   ctype, name, current_class_type);
10479                         return void_type_node;
10480                       }
10481                   }
10482                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10483                          || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
10484                   {
10485                     /* Have to move this code elsewhere in this function.
10486                        this code is used for i.e., typedef int A::M; M *pm;
10487
10488                        It is?  How? jason 10/2/94 */
10489
10490                     if (current_class_type)
10491                       {
10492                         cp_error ("cannot declare member `%T::%s' within `%T'",
10493                                   ctype, name, current_class_type);
10494                         return void_type_node;
10495                       }
10496                     type = build_offset_type (ctype, type);
10497                   }
10498                 else if (uses_template_parms (ctype))
10499                   {
10500                     if (TREE_CODE (type) == FUNCTION_TYPE)
10501                       type
10502                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10503                                                    TYPE_ARG_TYPES (type));
10504                   }
10505                 else
10506                   {
10507                     cp_error ("structure `%T' not yet defined", ctype);
10508                     return error_mark_node;
10509                   }
10510
10511                 declarator = sname;
10512               }
10513             else if (TREE_CODE (sname) == SCOPE_REF)
10514               my_friendly_abort (17);
10515             else
10516               {
10517               done_scoping:
10518                 declarator = TREE_OPERAND (declarator, 1);
10519                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10520                   /* In this case, we will deal with it later.  */
10521                   ;
10522                 else
10523                   {
10524                     if (TREE_CODE (type) == FUNCTION_TYPE)
10525                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10526                                                       TYPE_ARG_TYPES (type));
10527                     else
10528                       type = build_offset_type (ctype, type);
10529                   }
10530               }
10531           }
10532           break;
10533
10534         case BIT_NOT_EXPR:
10535           declarator = TREE_OPERAND (declarator, 0);
10536           break;
10537
10538         case RECORD_TYPE:
10539         case UNION_TYPE:
10540         case ENUMERAL_TYPE:
10541           declarator = NULL_TREE;
10542           break;
10543
10544         case ERROR_MARK:
10545           declarator = NULL_TREE;
10546           break;
10547
10548         default:
10549           my_friendly_abort (158);
10550         }
10551     }
10552
10553   /* See the comment for the TREE_LIST case, above.  */
10554   if (inner_attrs)
10555     {
10556       if (! ignore_attrs)
10557         decl_attributes (type, inner_attrs, NULL_TREE);
10558       else if (attrlist)
10559         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10560       else
10561         attrlist = build_decl_list (NULL_TREE, inner_attrs);
10562     }
10563
10564   /* Now TYPE has the actual type.  */
10565
10566   if (explicitp == 1 || (explicitp && friendp))
10567     {
10568       /* [dcl.fct.spec] The explicit specifier shall only be used in
10569          declarations of constructors within a class definition.  */
10570       error ("only declarations of constructors can be `explicit'");
10571       explicitp = 0;
10572     }
10573
10574   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10575     {
10576       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10577         {
10578           error ("non-member `%s' cannot be declared `mutable'", name);
10579           RIDBIT_RESET (RID_MUTABLE, specbits);
10580         }
10581       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10582         {
10583           error ("non-object member `%s' cannot be declared `mutable'", name);
10584           RIDBIT_RESET (RID_MUTABLE, specbits);
10585         }
10586       else if (TREE_CODE (type) == FUNCTION_TYPE
10587                || TREE_CODE (type) == METHOD_TYPE)
10588         {
10589           error ("function `%s' cannot be declared `mutable'", name);
10590           RIDBIT_RESET (RID_MUTABLE, specbits);
10591         }
10592       else if (staticp)
10593         {
10594           error ("static `%s' cannot be declared `mutable'", name);
10595           RIDBIT_RESET (RID_MUTABLE, specbits);
10596         }
10597       else if (type_quals & TYPE_QUAL_CONST)
10598         {
10599           error ("const `%s' cannot be declared `mutable'", name);
10600           RIDBIT_RESET (RID_MUTABLE, specbits);
10601         }
10602     }
10603
10604   if (declarator == NULL_TREE
10605       || TREE_CODE (declarator) == IDENTIFIER_NODE
10606       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10607           && (TREE_CODE (type) == FUNCTION_TYPE
10608               || TREE_CODE (type) == METHOD_TYPE)))
10609     /* OK */;
10610   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10611     {
10612       cp_error ("template-id `%D' used as a declarator", declarator);
10613       declarator = dname;
10614     }
10615   else
10616     /* Unexpected declarator format.  */
10617     my_friendly_abort (990210);
10618
10619   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10620
10621   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10622     {
10623       tree decl;
10624
10625       /* Note that the grammar rejects storage classes
10626          in typenames, fields or parameters.  */
10627       if (current_lang_name == lang_name_java)
10628         TYPE_FOR_JAVA (type) = 1;
10629
10630       if (decl_context == FIELD)
10631         {
10632           if (declarator == constructor_name (current_class_type))
10633             cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10634                         declarator);
10635           decl = build_lang_decl (TYPE_DECL, declarator, type);
10636         }
10637       else
10638         {
10639           /* Make sure this typedef lives as long as its type,
10640              since it might be used as a template parameter. */
10641           if (processing_template_decl)
10642             decl = build_lang_decl (TYPE_DECL, declarator, type);
10643           else
10644             decl = build_decl (TYPE_DECL, declarator, type);
10645         }
10646
10647       /* If the user declares "typedef struct {...} foo" then the
10648          struct will have an anonymous name.  Fill that name in now.
10649          Nothing can refer to it, so nothing needs know about the name
10650          change.  */
10651       if (type != error_mark_node
10652           && TYPE_NAME (type)
10653           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10654           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10655           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10656         {
10657           tree oldname = TYPE_NAME (type);
10658           tree t;
10659
10660           /* Replace the anonymous name with the real name everywhere.  */
10661           lookup_tag_reverse (type, declarator);
10662           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10663             if (TYPE_NAME (t) == oldname)
10664               TYPE_NAME (t) = decl;
10665
10666           if (TYPE_LANG_SPECIFIC (type))
10667             TYPE_WAS_ANONYMOUS (type) = 1;
10668
10669           /* If this is a typedef within a template class, the nested
10670              type is a (non-primary) template.  The name for the
10671              template needs updating as well.  */
10672           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10673             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10674               = TYPE_IDENTIFIER (type);
10675
10676           /* XXX Temporarily set the scope.
10677              When returning, start_decl expects it as NULL_TREE,
10678              and will then then set it using pushdecl. */
10679           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10680           if (current_class_type)
10681             DECL_CONTEXT (decl) = current_class_type;
10682           else
10683             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10684
10685           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10686           DECL_ASSEMBLER_NAME (decl)
10687             = get_identifier (build_overload_name (type, 1, 1));
10688           DECL_CONTEXT (decl) = NULL_TREE;
10689
10690           /* FIXME remangle member functions; member functions of a
10691              type with external linkage have external linkage.  */
10692         }
10693
10694       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10695         {
10696           cp_error_at ("typedef name may not be class-qualified", decl);
10697           return NULL_TREE;
10698         }
10699       else if (quals)
10700         {
10701           if (ctype == NULL_TREE)
10702             {
10703               if (TREE_CODE (type) != METHOD_TYPE)
10704                 cp_error_at ("invalid type qualifier for non-method type", decl);
10705               else
10706                 ctype = TYPE_METHOD_BASETYPE (type);
10707             }
10708           if (ctype != NULL_TREE)
10709             grok_method_quals (ctype, decl, quals);
10710         }
10711
10712       if (RIDBIT_SETP (RID_SIGNED, specbits)
10713           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10714         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10715
10716       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
10717                       inlinep, friendp, raises != NULL_TREE);
10718
10719       if (initialized)
10720         error ("typedef declaration includes an initializer");
10721
10722       return decl;
10723     }
10724
10725   /* Detect the case of an array type of unspecified size
10726      which came, as such, direct from a typedef name.
10727      We must copy the type, so that each identifier gets
10728      a distinct type, so that each identifier's size can be
10729      controlled separately by its own initializer.  */
10730
10731   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
10732       && TYPE_DOMAIN (type) == NULL_TREE)
10733     {
10734       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
10735     }
10736
10737   /* If this is a type name (such as, in a cast or sizeof),
10738      compute the type and return it now.  */
10739
10740   if (decl_context == TYPENAME)
10741     {
10742       /* Note that the grammar rejects storage classes
10743          in typenames, fields or parameters.  */
10744       if (type_quals != TYPE_UNQUALIFIED)
10745         type_quals = TYPE_UNQUALIFIED;
10746
10747       /* Special case: "friend class foo" looks like a TYPENAME context.  */
10748       if (friendp)
10749         {
10750           if (type_quals != TYPE_UNQUALIFIED)
10751             {
10752               cp_error ("type qualifiers specified for friend class declaration");
10753               type_quals = TYPE_UNQUALIFIED;
10754             }
10755           if (inlinep)
10756             {
10757               cp_error ("`inline' specified for friend class declaration");
10758               inlinep = 0;
10759             }
10760
10761           /* Only try to do this stuff if we didn't already give up.  */
10762           if (type != integer_type_node)
10763             {
10764               /* A friendly class?  */
10765               if (current_class_type)
10766                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
10767               else
10768                 error ("trying to make class `%s' a friend of global scope",
10769                        TYPE_NAME_STRING (type));
10770               type = void_type_node;
10771             }
10772         }
10773       else if (quals)
10774         {
10775           tree dummy = build_decl (TYPE_DECL, declarator, type);
10776           if (ctype == NULL_TREE)
10777             {
10778               my_friendly_assert (TREE_CODE (type) == METHOD_TYPE, 159);
10779               ctype = TYPE_METHOD_BASETYPE (type);
10780             }
10781           grok_method_quals (ctype, dummy, quals);
10782           type = TREE_TYPE (dummy);
10783         }
10784
10785       return type;
10786     }
10787   else if (declarator == NULL_TREE && decl_context != PARM
10788            && decl_context != CATCHPARM
10789            && TREE_CODE (type) != UNION_TYPE
10790            && ! bitfield)
10791     {
10792       cp_error ("abstract declarator `%T' used as declaration", type);
10793       declarator = make_anon_name ();
10794     }
10795
10796   /* `void' at top level (not within pointer)
10797      is allowed only in typedefs or type names.
10798      We don't complain about parms either, but that is because
10799      a better error message can be made later.  */
10800
10801   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
10802     {
10803       if (! declarator)
10804         error ("unnamed variable or field declared void");
10805       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10806         {
10807           if (IDENTIFIER_OPNAME_P (declarator))
10808             my_friendly_abort (356);
10809           else
10810             error ("variable or field `%s' declared void", name);
10811         }
10812       else
10813         error ("variable or field declared void");
10814       type = integer_type_node;
10815     }
10816
10817   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10818      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
10819
10820   if (decl_context == PARM || decl_context == CATCHPARM)
10821     {
10822       if (ctype || in_namespace)
10823         error ("cannot use `::' in parameter declaration");
10824
10825       /* A parameter declared as an array of T is really a pointer to T.
10826          One declared as a function is really a pointer to a function.
10827          One declared as a member is really a pointer to member.  */
10828
10829       if (TREE_CODE (type) == ARRAY_TYPE)
10830         {
10831           /* Transfer const-ness of array into that of type pointed to.  */
10832           type = build_pointer_type (TREE_TYPE (type));
10833           type_quals = TYPE_UNQUALIFIED;
10834         }
10835       else if (TREE_CODE (type) == FUNCTION_TYPE)
10836         type = build_pointer_type (type);
10837       else if (TREE_CODE (type) == OFFSET_TYPE)
10838         type = build_pointer_type (type);
10839       else if (TREE_CODE (type) == VOID_TYPE && declarator)
10840         {
10841           error ("declaration of `%s' as void", name);
10842           return NULL_TREE;
10843         }
10844     }
10845
10846   {
10847     register tree decl;
10848
10849     if (decl_context == PARM)
10850       {
10851         decl = build_decl (PARM_DECL, declarator, type);
10852
10853         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
10854                         inlinep, friendp, raises != NULL_TREE);
10855
10856         /* Compute the type actually passed in the parmlist,
10857            for the case where there is no prototype.
10858            (For example, shorts and chars are passed as ints.)
10859            When there is a prototype, this is overridden later.  */
10860
10861         DECL_ARG_TYPE (decl) = type_promotes_to (type);
10862       }
10863     else if (decl_context == FIELD)
10864       {
10865         if (type == error_mark_node)
10866           {
10867             /* Happens when declaring arrays of sizes which
10868                are error_mark_node, for example.  */
10869             decl = NULL_TREE;
10870           }
10871         else if (in_namespace && !friendp)
10872           {
10873             /* Something like struct S { int N::j; };  */
10874             cp_error ("invalid use of `::'");
10875             decl = NULL_TREE;
10876           }
10877         else if (TREE_CODE (type) == FUNCTION_TYPE)
10878           {
10879             int publicp = 0;
10880             tree function_context;
10881
10882             /* We catch the others as conflicts with the builtin
10883                typedefs.  */
10884             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
10885               {
10886                 cp_error ("function `%D' cannot be declared friend",
10887                           declarator);
10888                 friendp = 0;
10889               }
10890
10891             if (friendp == 0)
10892               {
10893                 if (ctype == NULL_TREE)
10894                   ctype = current_class_type;
10895
10896                 if (ctype == NULL_TREE)
10897                   {
10898                     cp_error ("can't make `%D' into a method -- not in a class",
10899                               declarator);
10900                     return void_type_node;
10901                   }
10902
10903                 /* ``A union may [ ... ] not [ have ] virtual functions.''
10904                    ARM 9.5 */
10905                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
10906                   {
10907                     cp_error ("function `%D' declared virtual inside a union",
10908                               declarator);
10909                     return void_type_node;
10910                   }
10911
10912                 if (declarator == ansi_opname[(int) NEW_EXPR]
10913                     || declarator == ansi_opname[(int) VEC_NEW_EXPR]
10914                     || declarator == ansi_opname[(int) DELETE_EXPR]
10915                     || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
10916                   {
10917                     if (virtualp)
10918                       {
10919                         cp_error ("`%D' cannot be declared virtual, since it is always static",
10920                                   declarator);
10921                         virtualp = 0;
10922                       }
10923                   }
10924                 else if (staticp < 2)
10925                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
10926                                                   TYPE_ARG_TYPES (type));
10927               }
10928
10929             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
10930             function_context = (ctype != NULL_TREE) ?
10931               hack_decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
10932             publicp = (! friendp || ! staticp)
10933               && function_context == NULL_TREE;
10934             decl = grokfndecl (ctype, type,
10935                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
10936                                ? declarator : dname,
10937                                declarator,
10938                                virtualp, flags, quals, raises,
10939                                friendp ? -1 : 0, friendp, publicp, inlinep,
10940                                funcdef_flag, template_count, in_namespace);
10941             if (decl == NULL_TREE)
10942               return decl;
10943 #if 0
10944             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
10945             /* The decl and setting of decl_machine_attr is also turned off.  */
10946             decl = build_decl_attribute_variant (decl, decl_machine_attr);
10947 #endif
10948
10949             /* [class.conv.ctor]
10950
10951                A constructor declared without the function-specifier
10952                explicit that can be called with a single parameter
10953                specifies a conversion from the type of its first
10954                parameter to the type of its class.  Such a constructor
10955                is called a converting constructor.  */
10956             if (explicitp == 2)
10957               DECL_NONCONVERTING_P (decl) = 1;
10958             else if (DECL_CONSTRUCTOR_P (decl))
10959               {
10960                 /* The constructor can be called with exactly one
10961                    parameter if there is at least one parameter, and
10962                    any subsequent parameters have default arguments.
10963                    We don't look at the first parameter, which is
10964                    really just the `this' parameter for the new
10965                    object.  */
10966                 tree arg_types =
10967                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
10968
10969                 /* Skip the `in_chrg' argument too, if present.  */
10970                 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl)))
10971                   arg_types = TREE_CHAIN (arg_types);
10972
10973                 if (arg_types == void_list_node
10974                     || (arg_types
10975                         && TREE_CHAIN (arg_types)
10976                         && TREE_CHAIN (arg_types) != void_list_node
10977                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
10978                   DECL_NONCONVERTING_P (decl) = 1;
10979               }
10980           }
10981         else if (TREE_CODE (type) == METHOD_TYPE)
10982           {
10983             /* We only get here for friend declarations of
10984                members of other classes.  */
10985             /* All method decls are public, so tell grokfndecl to set
10986                TREE_PUBLIC, also.  */
10987             decl = grokfndecl (ctype, type, declarator, declarator,
10988                                virtualp, flags, quals, raises,
10989                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
10990                                template_count, in_namespace);
10991             if (decl == NULL_TREE)
10992               return NULL_TREE;
10993           }
10994         else if (!staticp && ! processing_template_decl
10995                  && TYPE_SIZE (complete_type (type)) == NULL_TREE
10996                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
10997           {
10998             if (declarator)
10999               cp_error ("field `%D' has incomplete type", declarator);
11000             else
11001               cp_error ("name `%T' has incomplete type", type);
11002
11003             /* If we're instantiating a template, tell them which
11004                instantiation made the field's type be incomplete.  */
11005             if (current_class_type
11006                 && TYPE_NAME (current_class_type)
11007                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11008                 && declspecs && TREE_VALUE (declspecs)
11009                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11010               cp_error ("  in instantiation of template `%T'",
11011                         current_class_type);
11012
11013             type = error_mark_node;
11014             decl = NULL_TREE;
11015           }
11016         else
11017           {
11018             if (friendp)
11019               {
11020                 error ("`%s' is neither function nor method; cannot be declared friend",
11021                        IDENTIFIER_POINTER (declarator));
11022                 friendp = 0;
11023               }
11024             decl = NULL_TREE;
11025           }
11026
11027         if (friendp)
11028           {
11029             /* Friends are treated specially.  */
11030             if (ctype == current_class_type)
11031               warning ("member functions are implicitly friends of their class");
11032             else
11033               {
11034                 tree t = NULL_TREE;
11035                 if (decl && DECL_NAME (decl))
11036                   {
11037                     if (template_class_depth (current_class_type) == 0)
11038                       {
11039                         decl
11040                           = check_explicit_specialization
11041                           (declarator, decl,
11042                            template_count, 2 * (funcdef_flag != 0) + 4);
11043                         if (decl == error_mark_node)
11044                           return error_mark_node;
11045                       }
11046
11047                     t = do_friend (ctype, declarator, decl,
11048                                    last_function_parms, attrlist, flags, quals,
11049                                    funcdef_flag);
11050                   }
11051                 if (t && funcdef_flag)
11052                   return t;
11053
11054                 return void_type_node;
11055               }
11056           }
11057
11058         /* Structure field.  It may not be a function, except for C++ */
11059
11060         if (decl == NULL_TREE)
11061           {
11062             if (initialized)
11063               {
11064                 if (!staticp)
11065                   {
11066                     /* An attempt is being made to initialize a non-static
11067                        member.  But, from [class.mem]:
11068
11069                        4 A member-declarator can contain a
11070                        constant-initializer only if it declares a static
11071                        member (_class.static_) of integral or enumeration
11072                        type, see _class.static.data_.
11073
11074                        This used to be relatively common practice, but
11075                        the rest of the compiler does not correctly
11076                        handle the initialization unless the member is
11077                        static so we make it static below.  */
11078                     cp_pedwarn ("ANSI C++ forbids initialization of member `%D'",
11079                                 declarator);
11080                     cp_pedwarn ("making `%D' static", declarator);
11081                     staticp = 1;
11082                   }
11083
11084                 if (uses_template_parms (type))
11085                   /* We'll check at instantiation time.  */
11086                   ;
11087                 else if (check_static_variable_definition (declarator,
11088                                                            type))
11089                   /* If we just return the declaration, crashes
11090                      will sometimes occur.  We therefore return
11091                      void_type_node, as if this was a friend
11092                      declaration, to cause callers to completely
11093                      ignore this declaration.  */
11094                   return void_type_node;
11095               }
11096
11097             /* 9.2p13 [class.mem] */
11098             if (declarator == constructor_name (current_class_type)
11099                 /* Divergence from the standard:  In extern "C", we
11100                    allow non-static data members here, because C does
11101                    and /usr/include/netinet/in.h uses that.  */
11102                 && (staticp || ! in_system_header))
11103               cp_pedwarn ("ANSI C++ forbids data member `%D' with same name as enclosing class",
11104                           declarator);
11105
11106             if (staticp)
11107               {
11108                 /* C++ allows static class members.  All other work
11109                    for this is done by grokfield.  */
11110                 decl = build_lang_decl (VAR_DECL, declarator, type);
11111                 TREE_STATIC (decl) = 1;
11112                 /* In class context, 'static' means public access.  */
11113                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11114               }
11115             else
11116               {
11117                 decl = build_lang_decl (FIELD_DECL, declarator, type);
11118                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11119                   {
11120                     DECL_MUTABLE_P (decl) = 1;
11121                     RIDBIT_RESET (RID_MUTABLE, specbits);
11122                   }
11123               }
11124
11125             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11126                             inlinep, friendp, raises != NULL_TREE);
11127           }
11128       }
11129     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11130       {
11131         tree original_name;
11132         int publicp = 0;
11133
11134         if (! declarator)
11135           return NULL_TREE;
11136
11137         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11138           original_name = dname;
11139         else
11140           original_name = declarator;
11141
11142         if (RIDBIT_SETP (RID_AUTO, specbits))
11143           error ("storage class `auto' invalid for function `%s'", name);
11144         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11145           error ("storage class `register' invalid for function `%s'", name);
11146
11147         /* Function declaration not at top level.
11148            Storage classes other than `extern' are not allowed
11149            and `extern' makes no difference.  */
11150         if (! toplevel_bindings_p ()
11151             && (RIDBIT_SETP (RID_STATIC, specbits)
11152                 || RIDBIT_SETP (RID_INLINE, specbits))
11153             && pedantic)
11154           {
11155             if (RIDBIT_SETP (RID_STATIC, specbits))
11156               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11157             else
11158               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11159           }
11160
11161         if (ctype == NULL_TREE)
11162           {
11163             if (virtualp)
11164               {
11165                 error ("virtual non-class function `%s'", name);
11166                 virtualp = 0;
11167               }
11168           }
11169         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11170           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11171                                           TYPE_ARG_TYPES (type));
11172
11173         /* Record presence of `static'.  */
11174         publicp = (ctype != NULL_TREE
11175                    || RIDBIT_SETP (RID_EXTERN, specbits)
11176                    || !RIDBIT_SETP (RID_STATIC, specbits));
11177
11178         decl = grokfndecl (ctype, type, original_name, declarator,
11179                            virtualp, flags, quals, raises,
11180                            1, friendp,
11181                            publicp, inlinep, funcdef_flag,
11182                            template_count, in_namespace);
11183         if (decl == NULL_TREE)
11184           return NULL_TREE;
11185
11186         if (staticp == 1)
11187           {
11188             int illegal_static = 0;
11189
11190             /* Don't allow a static member function in a class, and forbid
11191                declaring main to be static.  */
11192             if (TREE_CODE (type) == METHOD_TYPE)
11193               {
11194                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11195                 illegal_static = 1;
11196               }
11197             else if (current_function_decl)
11198               {
11199                 /* FIXME need arm citation */
11200                 error ("cannot declare static function inside another function");
11201                 illegal_static = 1;
11202               }
11203
11204             if (illegal_static)
11205               {
11206                 staticp = 0;
11207                 RIDBIT_RESET (RID_STATIC, specbits);
11208               }
11209           }
11210       }
11211     else
11212       {
11213         /* It's a variable.  */
11214
11215         /* An uninitialized decl with `extern' is a reference.  */
11216         decl = grokvardecl (type, declarator, &specbits,
11217                             initialized,
11218                             (type_quals & TYPE_QUAL_CONST) != 0,
11219                             in_namespace);
11220         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11221                         inlinep, friendp, raises != NULL_TREE);
11222
11223         if (ctype)
11224           {
11225             DECL_CONTEXT (decl) = ctype;
11226             if (staticp == 1)
11227               {
11228                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11229                 staticp = 0;
11230                 RIDBIT_RESET (RID_STATIC, specbits);
11231               }
11232             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11233               {
11234                 cp_error ("static member `%D' declared `register'", decl);
11235                 RIDBIT_RESET (RID_REGISTER, specbits);
11236               }
11237             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11238               {
11239                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11240                             decl);
11241                 RIDBIT_RESET (RID_EXTERN, specbits);
11242               }
11243           }
11244       }
11245
11246     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11247
11248     /* Record `register' declaration for warnings on &
11249        and in case doing stupid register allocation.  */
11250
11251     if (RIDBIT_SETP (RID_REGISTER, specbits))
11252       DECL_REGISTER (decl) = 1;
11253
11254     if (RIDBIT_SETP (RID_EXTERN, specbits))
11255       DECL_THIS_EXTERN (decl) = 1;
11256
11257     if (RIDBIT_SETP (RID_STATIC, specbits))
11258       DECL_THIS_STATIC (decl) = 1;
11259
11260     /* Record constancy and volatility.  There's no need to do this
11261        when processing a template; we'll do this for the instantiated
11262        declaration based on the type of DECL.  */
11263     if (!processing_template_decl)
11264       c_apply_type_quals_to_decl (type_quals, decl);
11265
11266     return decl;
11267   }
11268 }
11269 \f
11270 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11271    An empty exprlist is a parmlist.  An exprlist which
11272    contains only identifiers at the global level
11273    is a parmlist.  Otherwise, it is an exprlist.  */
11274
11275 int
11276 parmlist_is_exprlist (exprs)
11277      tree exprs;
11278 {
11279   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11280     return 0;
11281
11282   if (toplevel_bindings_p ())
11283     {
11284       /* At the global level, if these are all identifiers,
11285          then it is a parmlist.  */
11286       while (exprs)
11287         {
11288           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11289             return 1;
11290           exprs = TREE_CHAIN (exprs);
11291         }
11292       return 0;
11293     }
11294   return 1;
11295 }
11296
11297 /* Subroutine of start_function.  Ensure that each of the parameter
11298    types (as listed in PARMS) is complete, as is required for a
11299    function definition.  */
11300
11301 static void
11302 require_complete_types_for_parms (parms)
11303      tree parms;
11304 {
11305   while (parms)
11306     {
11307       tree type = TREE_TYPE (parms);
11308       if (TYPE_SIZE (complete_type (type)) == NULL_TREE)
11309         {
11310           if (DECL_NAME (parms))
11311             error ("parameter `%s' has incomplete type",
11312                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11313           else
11314             error ("parameter has incomplete type");
11315           TREE_TYPE (parms) = error_mark_node;
11316         }
11317       else
11318         layout_decl (parms, 0);
11319
11320       parms = TREE_CHAIN (parms);
11321     }
11322 }
11323
11324 /* Returns non-zero if T is a local variable.  */
11325
11326 int
11327 local_variable_p (t)
11328      tree t;
11329 {
11330   if ((TREE_CODE (t) == VAR_DECL
11331        /* A VAR_DECL with a context that is a _TYPE is a static data
11332           member.  */
11333        && !TYPE_P (CP_DECL_CONTEXT (t))
11334        /* Any other non-local variable must be at namespace scope.  */
11335        && !DECL_NAMESPACE_SCOPE_P (t))
11336       || (TREE_CODE (t) == PARM_DECL))
11337     return 1;
11338
11339   return 0;
11340 }
11341
11342 /* Returns non-zero if T is an automatic local variable or a label.
11343    (These are the declarations that need to be remapped when the code
11344    containing them is duplicated.)  */
11345
11346 int
11347 nonstatic_local_decl_p (t)
11348      tree t;
11349 {
11350   return ((local_variable_p (t) && !TREE_STATIC (t))
11351           || TREE_CODE (t) == LABEL_DECL
11352           || TREE_CODE (t) == RESULT_DECL);
11353 }
11354
11355 /* Like local_variable_p, but suitable for use as a tree-walking
11356    function.  */
11357
11358 static tree
11359 local_variable_p_walkfn (tp, walk_subtrees, data)
11360      tree *tp;
11361      int *walk_subtrees ATTRIBUTE_UNUSED;
11362      void *data ATTRIBUTE_UNUSED;
11363 {
11364   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11365           ? *tp : NULL_TREE);
11366 }
11367
11368 /* Check that ARG, which is a default-argument expression for a
11369    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11370    something goes wrong.  DECL may also be a _TYPE node, rather than a
11371    DECL, if there is no DECL available.  */
11372
11373 tree
11374 check_default_argument (decl, arg)
11375      tree decl;
11376      tree arg;
11377 {
11378   tree var;
11379   tree decl_type;
11380
11381   if (TREE_CODE (arg) == DEFAULT_ARG)
11382     /* We get a DEFAULT_ARG when looking at an in-class declaration
11383        with a default argument.  Ignore the argument for now; we'll
11384        deal with it after the class is complete.  */
11385     return arg;
11386
11387   if (processing_template_decl || uses_template_parms (arg))
11388     /* We don't do anything checking until instantiation-time.  Note
11389        that there may be uninstantiated arguments even for an
11390        instantiated function, since default arguments are not
11391        instantiated until they are needed.  */
11392     return arg;
11393
11394   if (TYPE_P (decl))
11395     {
11396       decl_type = decl;
11397       decl = NULL_TREE;
11398     }
11399   else
11400     decl_type = TREE_TYPE (decl);
11401
11402   if (arg == error_mark_node
11403       || decl == error_mark_node
11404       || TREE_TYPE (arg) == error_mark_node
11405       || decl_type == error_mark_node)
11406     /* Something already went wrong.  There's no need to check
11407        further.  */
11408     return error_mark_node;
11409
11410   /* [dcl.fct.default]
11411
11412      A default argument expression is implicitly converted to the
11413      parameter type.  */
11414   if (!TREE_TYPE (arg)
11415       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11416     {
11417       if (decl)
11418         cp_error ("default argument for `%#D' has type `%T'",
11419                   decl, TREE_TYPE (arg));
11420       else
11421         cp_error ("default argument for parameter of type `%T' has type `%T'",
11422                   decl_type, TREE_TYPE (arg));
11423
11424       return error_mark_node;
11425     }
11426
11427   /* [dcl.fct.default]
11428
11429      Local variables shall not be used in default argument
11430      expressions.
11431
11432      The keyword `this' shall not be used in a default argument of a
11433      member function.  */
11434   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11435   if (var)
11436     {
11437       cp_error ("default argument `%E' uses local variable `%D'",
11438                 arg, var);
11439       return error_mark_node;
11440     }
11441
11442   /* All is well.  */
11443   return arg;
11444 }
11445
11446 /* Decode the list of parameter types for a function type.
11447    Given the list of things declared inside the parens,
11448    return a list of types.
11449
11450    The list we receive can have three kinds of elements:
11451    an IDENTIFIER_NODE for names given without types,
11452    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11453    or void_type_node, to mark the end of an argument list
11454    when additional arguments are not permitted (... was not used).
11455
11456    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11457    a mere declaration.  A nonempty identifier-list gets an error message
11458    when FUNCDEF_FLAG is zero.
11459    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11460    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11461
11462    If all elements of the input list contain types,
11463    we return a list of the types.
11464    If all elements contain no type (except perhaps a void_type_node
11465    at the end), we return a null list.
11466    If some have types and some do not, it is an error, and we
11467    return a null list.
11468
11469    Also set last_function_parms to either
11470    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11471    A list of names is converted to a chain of PARM_DECLs
11472    by store_parm_decls so that ultimately it is always a chain of decls.
11473
11474    Note that in C++, parameters can take default values.  These default
11475    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11476    an error to specify default values which are followed by parameters
11477    that have no default values, or an ELLIPSES.  For simplicities sake,
11478    only parameters which are specified with their types can take on
11479    default values.  */
11480
11481 static tree
11482 grokparms (first_parm, funcdef_flag)
11483      tree first_parm;
11484      int funcdef_flag;
11485 {
11486   tree result = NULL_TREE;
11487   tree decls = NULL_TREE;
11488
11489   if (first_parm != NULL_TREE
11490       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11491     {
11492       if (! funcdef_flag)
11493         pedwarn ("parameter names (without types) in function declaration");
11494       last_function_parms = first_parm;
11495       return NULL_TREE;
11496     }
11497   else if (first_parm != NULL_TREE
11498            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11499            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11500     my_friendly_abort (145);
11501   else
11502     {
11503       /* Types were specified.  This is a list of declarators
11504          each represented as a TREE_LIST node.  */
11505       register tree parm, chain;
11506       int any_init = 0, any_error = 0;
11507
11508       if (first_parm != NULL_TREE)
11509         {
11510           tree last_result = NULL_TREE;
11511           tree last_decl = NULL_TREE;
11512
11513           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11514             {
11515               tree type = NULL_TREE, list_node = parm;
11516               register tree decl = TREE_VALUE (parm);
11517               tree init = TREE_PURPOSE (parm);
11518
11519               chain = TREE_CHAIN (parm);
11520               /* @@ weak defense against parse errors.  */
11521               if (TREE_CODE (decl) != VOID_TYPE
11522                   && TREE_CODE (decl) != TREE_LIST)
11523                 {
11524                   /* Give various messages as the need arises.  */
11525                   if (TREE_CODE (decl) == STRING_CST)
11526                     cp_error ("invalid string constant `%E'", decl);
11527                   else if (TREE_CODE (decl) == INTEGER_CST)
11528                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11529                   continue;
11530                 }
11531
11532               if (TREE_CODE (decl) != VOID_TYPE)
11533                 {
11534                   decl = grokdeclarator (TREE_VALUE (decl),
11535                                          TREE_PURPOSE (decl),
11536                                          PARM, init != NULL_TREE,
11537                                          NULL_TREE);
11538                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11539                     continue;
11540
11541                   /* Top-level qualifiers on the parameters are
11542                      ignored for function types.  */
11543                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11544
11545                   if (TREE_CODE (type) == VOID_TYPE)
11546                     decl = void_type_node;
11547                   else if (TREE_CODE (type) == METHOD_TYPE)
11548                     {
11549                       if (DECL_NAME (decl))
11550                         /* Cannot use the decl here because
11551                            we don't have DECL_CONTEXT set up yet.  */
11552                         cp_error ("parameter `%D' invalidly declared method type",
11553                                   DECL_NAME (decl));
11554                       else
11555                         error ("parameter invalidly declared method type");
11556                       type = build_pointer_type (type);
11557                       TREE_TYPE (decl) = type;
11558                     }
11559                   else if (TREE_CODE (type) == OFFSET_TYPE)
11560                     {
11561                       if (DECL_NAME (decl))
11562                         cp_error ("parameter `%D' invalidly declared offset type",
11563                                   DECL_NAME (decl));
11564                       else
11565                         error ("parameter invalidly declared offset type");
11566                       type = build_pointer_type (type);
11567                       TREE_TYPE (decl) = type;
11568                     }
11569                   else if (abstract_virtuals_error (decl, type))
11570                     any_error = 1;  /* Seems like a good idea. */
11571                   else if (POINTER_TYPE_P (type))
11572                     {
11573                       tree t = type;
11574                       while (POINTER_TYPE_P (t)
11575                              || (TREE_CODE (t) == ARRAY_TYPE
11576                                  && TYPE_DOMAIN (t) != NULL_TREE))
11577                         t = TREE_TYPE (t);
11578                       if (TREE_CODE (t) == ARRAY_TYPE)
11579                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
11580                                   type,
11581                                   TYPE_PTR_P (type) ? "pointer" : "reference");
11582                     }
11583                 }
11584
11585               if (TREE_CODE (decl) == VOID_TYPE)
11586                 {
11587                   if (result == NULL_TREE)
11588                     {
11589                       result = void_list_node;
11590                       last_result = result;
11591                     }
11592                   else
11593                     {
11594                       TREE_CHAIN (last_result) = void_list_node;
11595                       last_result = void_list_node;
11596                     }
11597                   if (chain
11598                       && (chain != void_list_node || TREE_CHAIN (chain)))
11599                     error ("`void' in parameter list must be entire list");
11600                   break;
11601                 }
11602
11603               /* Since there is a prototype, args are passed in their own types.  */
11604               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11605               if (PROMOTE_PROTOTYPES
11606                   && (TREE_CODE (type) == INTEGER_TYPE
11607                       || TREE_CODE (type) == ENUMERAL_TYPE)
11608                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11609                 DECL_ARG_TYPE (decl) = integer_type_node;
11610               if (!any_error && init)
11611                 {
11612                   any_init++;
11613                   init = check_default_argument (decl, init);
11614                 }
11615               else
11616                 init = NULL_TREE;
11617
11618               if (decls == NULL_TREE)
11619                 {
11620                   decls = decl;
11621                   last_decl = decls;
11622                 }
11623               else
11624                 {
11625                   TREE_CHAIN (last_decl) = decl;
11626                   last_decl = decl;
11627                 }
11628               list_node = tree_cons (init, type, NULL_TREE);
11629               if (result == NULL_TREE)
11630                 {
11631                   result = list_node;
11632                   last_result = result;
11633                 }
11634               else
11635                 {
11636                   TREE_CHAIN (last_result) = list_node;
11637                   last_result = list_node;
11638                 }
11639             }
11640           if (last_result)
11641             TREE_CHAIN (last_result) = NULL_TREE;
11642           /* If there are no parameters, and the function does not end
11643              with `...', then last_decl will be NULL_TREE.  */
11644           if (last_decl != NULL_TREE)
11645             TREE_CHAIN (last_decl) = NULL_TREE;
11646         }
11647     }
11648
11649   last_function_parms = decls;
11650
11651   return result;
11652 }
11653
11654 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11655    FUNCTION_TYPE with the newly parsed version of its default argument, which
11656    was previously digested as text.  See snarf_defarg et al in lex.c.  */
11657
11658 void
11659 replace_defarg (arg, init)
11660      tree arg, init;
11661 {
11662   if (! processing_template_decl
11663       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11664     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11665                 TREE_TYPE (init), TREE_VALUE (arg));
11666   TREE_PURPOSE (arg) = init;
11667 }
11668 \f
11669 int
11670 copy_args_p (d)
11671      tree d;
11672 {
11673   tree t = FUNCTION_ARG_CHAIN (d);
11674   if (DECL_CONSTRUCTOR_P (d)
11675       && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
11676     t = TREE_CHAIN (t);
11677   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11678       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11679           == DECL_CLASS_CONTEXT (d))
11680       && (TREE_CHAIN (t) == NULL_TREE
11681           || TREE_CHAIN (t) == void_list_node
11682           || TREE_PURPOSE (TREE_CHAIN (t))))
11683     return 1;
11684   return 0;
11685 }
11686
11687 /* These memoizing functions keep track of special properties which
11688    a class may have.  `grok_ctor_properties' notices whether a class
11689    has a constructor of the form X(X&), and also complains
11690    if the class has a constructor of the form X(X).
11691    `grok_op_properties' takes notice of the various forms of
11692    operator= which are defined, as well as what sorts of type conversion
11693    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11694
11695 int
11696 grok_ctor_properties (ctype, decl)
11697      tree ctype, decl;
11698 {
11699   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11700   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11701
11702   /* When a type has virtual baseclasses, a magical first int argument is
11703      added to any ctor so we can tell if the class has been initialized
11704      yet.  This could screw things up in this function, so we deliberately
11705      ignore the leading int if we're in that situation.  */
11706   if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
11707     {
11708       my_friendly_assert (parmtypes
11709                           && TREE_VALUE (parmtypes) == integer_type_node,
11710                           980529);
11711       parmtypes = TREE_CHAIN (parmtypes);
11712       parmtype = TREE_VALUE (parmtypes);
11713     }
11714
11715   /* [class.copy]
11716
11717      A non-template constructor for class X is a copy constructor if
11718      its first parameter is of type X&, const X&, volatile X& or const
11719      volatile X&, and either there are no other parameters or else all
11720      other parameters have default arguments.  */
11721   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11722       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11723       && (TREE_CHAIN (parmtypes) == NULL_TREE
11724           || TREE_CHAIN (parmtypes) == void_list_node
11725           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11726       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11727            && is_member_template (DECL_TI_TEMPLATE (decl))))
11728     {
11729       TYPE_HAS_INIT_REF (ctype) = 1;
11730       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11731         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11732     }
11733   /* [class.copy]
11734
11735      A declaration of a constructor for a class X is ill-formed if its
11736      first parameter is of type (optionally cv-qualified) X and either
11737      there are no other parameters or else all other parameters have
11738      default arguments.
11739
11740      We *don't* complain about member template instantiations that
11741      have this form, though; they can occur as we try to decide what
11742      constructor to use during overload resolution.  Since overload
11743      resolution will never prefer such a constructor to the
11744      non-template copy constructor (which is either explicitly or
11745      implicitly defined), there's no need to worry about their
11746      existence.  Theoretically, they should never even be
11747      instantiated, but that's hard to forestall.  */
11748   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11749            && (TREE_CHAIN (parmtypes) == NULL_TREE
11750                || TREE_CHAIN (parmtypes) == void_list_node
11751                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11752            && !(DECL_TEMPLATE_INSTANTIATION (decl)
11753                 && is_member_template (DECL_TI_TEMPLATE (decl))))
11754     {
11755       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11756                 ctype, ctype);
11757       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
11758       return 0;
11759     }
11760   else if (TREE_CODE (parmtype) == VOID_TYPE
11761            || TREE_PURPOSE (parmtypes) != NULL_TREE)
11762     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
11763
11764   return 1;
11765 }
11766
11767 /* An operator with this name can be either unary or binary.  */
11768
11769 static int
11770 ambi_op_p (name)
11771      tree name;
11772 {
11773   return (name == ansi_opname [(int) INDIRECT_REF]
11774           || name == ansi_opname [(int) ADDR_EXPR]
11775           || name == ansi_opname [(int) NEGATE_EXPR]
11776           || name == ansi_opname[(int) POSTINCREMENT_EXPR]
11777           || name == ansi_opname[(int) POSTDECREMENT_EXPR]
11778           || name == ansi_opname [(int) CONVERT_EXPR]);
11779 }
11780
11781 /* An operator with this name can only be unary.  */
11782
11783 static int
11784 unary_op_p (name)
11785      tree name;
11786 {
11787   return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
11788           || name == ansi_opname [(int) BIT_NOT_EXPR]
11789           || name == ansi_opname [(int) COMPONENT_REF]
11790           || IDENTIFIER_TYPENAME_P (name));
11791 }
11792
11793 /* Do a little sanity-checking on how they declared their operator.  */
11794
11795 void
11796 grok_op_properties (decl, virtualp, friendp)
11797      tree decl;
11798      int virtualp, friendp;
11799 {
11800   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11801   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11802   tree name = DECL_NAME (decl);
11803
11804   if (current_class_type == NULL_TREE)
11805     friendp = 1;
11806
11807   if (! friendp)
11808     {
11809       /* [class.copy]
11810
11811          A user-declared copy assignment operator X::operator= is a
11812          non-static non-template member function of class X with
11813          exactly one parameter of type X, X&, const X&, volatile X& or
11814          const volatile X&.  */
11815       if (name == ansi_opname[(int) MODIFY_EXPR]
11816           && !(DECL_TEMPLATE_INSTANTIATION (decl)
11817                && is_member_template (DECL_TI_TEMPLATE (decl))))
11818         ;
11819       else if (name == ansi_opname[(int) CALL_EXPR])
11820         TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
11821       else if (name == ansi_opname[(int) ARRAY_REF])
11822         TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
11823       else if (name == ansi_opname[(int) COMPONENT_REF]
11824                || name == ansi_opname[(int) MEMBER_REF])
11825         TYPE_OVERLOADS_ARROW (current_class_type) = 1;
11826       else if (name == ansi_opname[(int) NEW_EXPR])
11827         TYPE_GETS_NEW (current_class_type) |= 1;
11828       else if (name == ansi_opname[(int) DELETE_EXPR])
11829         TYPE_GETS_DELETE (current_class_type) |= 1;
11830       else if (name == ansi_opname[(int) VEC_NEW_EXPR])
11831         TYPE_GETS_NEW (current_class_type) |= 2;
11832       else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
11833         TYPE_GETS_DELETE (current_class_type) |= 2;
11834     }
11835
11836   if (name == ansi_opname[(int) NEW_EXPR]
11837       || name == ansi_opname[(int) VEC_NEW_EXPR])
11838     {
11839       /* When the compiler encounters the definition of A::operator new, it
11840          doesn't look at the class declaration to find out if it's static.  */
11841       if (methodp)
11842         revert_static_member_fn (&decl, NULL, NULL);
11843
11844       /* Take care of function decl if we had syntax errors.  */
11845       if (argtypes == NULL_TREE)
11846         TREE_TYPE (decl)
11847           = build_function_type (ptr_type_node,
11848                                  hash_tree_chain (integer_type_node,
11849                                                   void_list_node));
11850       else
11851         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
11852     }
11853   else if (name == ansi_opname[(int) DELETE_EXPR]
11854            || name == ansi_opname[(int) VEC_DELETE_EXPR])
11855     {
11856       if (methodp)
11857         revert_static_member_fn (&decl, NULL, NULL);
11858
11859       if (argtypes == NULL_TREE)
11860         TREE_TYPE (decl)
11861           = build_function_type (void_type_node,
11862                                  hash_tree_chain (ptr_type_node,
11863                                                   void_list_node));
11864       else
11865         {
11866           TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
11867
11868           if (! friendp && name == ansi_opname[(int) VEC_DELETE_EXPR]
11869               && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
11870                   != void_list_node))
11871             TYPE_VEC_DELETE_TAKES_SIZE (current_class_type) = 1;
11872         }
11873     }
11874   else
11875     {
11876       /* An operator function must either be a non-static member function
11877          or have at least one parameter of a class, a reference to a class,
11878          an enumeration, or a reference to an enumeration.  13.4.0.6 */
11879       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
11880         {
11881           if (IDENTIFIER_TYPENAME_P (name)
11882               || name == ansi_opname[(int) CALL_EXPR]
11883               || name == ansi_opname[(int) MODIFY_EXPR]
11884               || name == ansi_opname[(int) COMPONENT_REF]
11885               || name == ansi_opname[(int) ARRAY_REF])
11886             cp_error ("`%D' must be a nonstatic member function", decl);
11887           else
11888             {
11889               tree p = argtypes;
11890
11891               if (DECL_STATIC_FUNCTION_P (decl))
11892                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
11893
11894               if (p)
11895                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
11896                   {
11897                     tree arg = TREE_VALUE (p);
11898                     if (TREE_CODE (arg) == REFERENCE_TYPE)
11899                       arg = TREE_TYPE (arg);
11900
11901                     /* This lets bad template code slip through.  */
11902                     if (IS_AGGR_TYPE (arg)
11903                         || TREE_CODE (arg) == ENUMERAL_TYPE
11904                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
11905                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
11906                       goto foundaggr;
11907                   }
11908               cp_error
11909                 ("`%D' must have an argument of class or enumerated type",
11910                  decl);
11911             foundaggr:
11912               ;
11913             }
11914         }
11915
11916       if (name == ansi_opname[(int) CALL_EXPR])
11917         return;                 /* No restrictions on args. */
11918
11919       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
11920         {
11921           tree t = TREE_TYPE (name);
11922           if (TREE_CODE (t) == VOID_TYPE)
11923             pedwarn ("void is not a valid type conversion operator");
11924           else if (! friendp)
11925             {
11926               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
11927               const char *what = 0;
11928               if (ref)
11929                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
11930
11931               if (t == current_class_type)
11932                 what = "the same type";
11933               /* Don't force t to be complete here.  */
11934               else if (IS_AGGR_TYPE (t)
11935                        && TYPE_SIZE (t)
11936                        && DERIVED_FROM_P (t, current_class_type))
11937                 what = "a base class";
11938
11939               if (what)
11940                 warning ("conversion to %s%s will never use a type conversion operator",
11941                          ref ? "a reference to " : "", what);
11942             }
11943         }
11944
11945       if (name == ansi_opname[(int) MODIFY_EXPR])
11946         {
11947           tree parmtype;
11948
11949           if (list_length (argtypes) != 3 && methodp)
11950             {
11951               cp_error ("`%D' must take exactly one argument", decl);
11952               return;
11953             }
11954           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
11955
11956           if (copy_assignment_arg_p (parmtype, virtualp)
11957               && ! friendp)
11958             {
11959               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
11960               if (TREE_CODE (parmtype) != REFERENCE_TYPE
11961                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11962                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
11963             }
11964         }
11965       else if (name == ansi_opname[(int) COND_EXPR])
11966         {
11967           /* 13.4.0.3 */
11968           cp_error ("ANSI C++ prohibits overloading operator ?:");
11969         }
11970       else if (ambi_op_p (name))
11971         {
11972           if (list_length (argtypes) == 2)
11973             /* prefix */;
11974           else if (list_length (argtypes) == 3)
11975             {
11976               if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
11977                    || name == ansi_opname[(int) POSTDECREMENT_EXPR])
11978                   && ! processing_template_decl
11979                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
11980                 {
11981                   if (methodp)
11982                     cp_error ("postfix `%D' must take `int' as its argument",
11983                               decl);
11984                   else
11985                     cp_error
11986                       ("postfix `%D' must take `int' as its second argument",
11987                        decl);
11988                 }
11989             }
11990           else
11991             {
11992               if (methodp)
11993                 cp_error ("`%D' must take either zero or one argument", decl);
11994               else
11995                 cp_error ("`%D' must take either one or two arguments", decl);
11996             }
11997
11998           /* More Effective C++ rule 6.  */
11999           if (warn_ecpp
12000               && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12001                   || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
12002             {
12003               tree arg = TREE_VALUE (argtypes);
12004               tree ret = TREE_TYPE (TREE_TYPE (decl));
12005               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12006                 arg = TREE_TYPE (arg);
12007               arg = TYPE_MAIN_VARIANT (arg);
12008               if (list_length (argtypes) == 2)
12009                 {
12010                   if (TREE_CODE (ret) != REFERENCE_TYPE
12011                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12012                                        arg))
12013                     cp_warning ("prefix `%D' should return `%T'", decl,
12014                                 build_reference_type (arg));
12015                 }
12016               else
12017                 {
12018                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12019                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12020                 }
12021             }
12022         }
12023       else if (unary_op_p (name))
12024         {
12025           if (list_length (argtypes) != 2)
12026             {
12027               if (methodp)
12028                 cp_error ("`%D' must take `void'", decl);
12029               else
12030                 cp_error ("`%D' must take exactly one argument", decl);
12031             }
12032         }
12033       else /* if (binary_op_p (name)) */
12034         {
12035           if (list_length (argtypes) != 3)
12036             {
12037               if (methodp)
12038                 cp_error ("`%D' must take exactly one argument", decl);
12039               else
12040                 cp_error ("`%D' must take exactly two arguments", decl);
12041             }
12042
12043           /* More Effective C++ rule 7.  */
12044           if (warn_ecpp
12045               && (name == ansi_opname [TRUTH_ANDIF_EXPR]
12046                   || name == ansi_opname [TRUTH_ORIF_EXPR]
12047                   || name == ansi_opname [COMPOUND_EXPR]))
12048             cp_warning ("user-defined `%D' always evaluates both arguments",
12049                         decl);
12050         }
12051
12052       /* Effective C++ rule 23.  */
12053       if (warn_ecpp
12054           && list_length (argtypes) == 3
12055           && (name == ansi_opname [PLUS_EXPR]
12056               || name == ansi_opname [MINUS_EXPR]
12057               || name == ansi_opname [TRUNC_DIV_EXPR]
12058               || name == ansi_opname [MULT_EXPR])
12059           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12060         cp_warning ("`%D' should return by value", decl);
12061
12062       /* 13.4.0.8 */
12063       if (argtypes)
12064         for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
12065           if (TREE_PURPOSE (argtypes))
12066             {
12067               TREE_PURPOSE (argtypes) = NULL_TREE;
12068               if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12069                   || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12070                 {
12071                   if (pedantic)
12072                     cp_pedwarn ("`%D' cannot have default arguments", decl);
12073                 }
12074               else
12075                 cp_error ("`%D' cannot have default arguments", decl);
12076             }
12077     }
12078 }
12079 \f
12080 static const char *
12081 tag_name (code)
12082      enum tag_types code;
12083 {
12084   switch (code)
12085     {
12086     case record_type:
12087       return "struct";
12088     case class_type:
12089       return "class";
12090     case union_type:
12091       return "union ";
12092     case enum_type:
12093       return "enum";
12094     default:
12095       my_friendly_abort (981122);
12096     }
12097 }
12098
12099 /* Get the struct, enum or union (CODE says which) with tag NAME.
12100    Define the tag as a forward-reference if it is not defined.
12101
12102    C++: If a class derivation is given, process it here, and report
12103    an error if multiple derivation declarations are not identical.
12104
12105    If this is a definition, come in through xref_tag and only look in
12106    the current frame for the name (since C++ allows new names in any
12107    scope.)  */
12108
12109 tree
12110 xref_tag (code_type_node, name, globalize)
12111      tree code_type_node;
12112      tree name;
12113      int globalize;
12114 {
12115   enum tag_types tag_code;
12116   enum tree_code code;
12117   register tree ref, t;
12118   struct binding_level *b = current_binding_level;
12119   int got_type = 0;
12120   tree attributes = NULL_TREE;
12121   tree context = NULL_TREE;
12122
12123   /* If we are called from the parser, code_type_node will sometimes be a
12124      TREE_LIST.  This indicates that the user wrote
12125      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12126      use them later.  */
12127   if (TREE_CODE (code_type_node) == TREE_LIST)
12128     {
12129       attributes = TREE_PURPOSE (code_type_node);
12130       code_type_node = TREE_VALUE (code_type_node);
12131     }
12132
12133   tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12134   switch (tag_code)
12135     {
12136     case record_type:
12137     case class_type:
12138       code = RECORD_TYPE;
12139       break;
12140     case union_type:
12141       code = UNION_TYPE;
12142       break;
12143     case enum_type:
12144       code = ENUMERAL_TYPE;
12145       break;
12146     default:
12147       my_friendly_abort (18);
12148     }
12149
12150   /* If a cross reference is requested, look up the type
12151      already defined for this tag and return it.  */
12152   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
12153     {
12154       t = name;
12155       name = TYPE_IDENTIFIER (t);
12156       got_type = 1;
12157     }
12158   else
12159     t = IDENTIFIER_TYPE_VALUE (name);
12160
12161   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12162       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12163     t = NULL_TREE;
12164
12165   if (! globalize)
12166     {
12167       /* If we know we are defining this tag, only look it up in
12168          this scope and don't try to find it as a type.  */
12169       ref = lookup_tag (code, name, b, 1);
12170     }
12171   else
12172     {
12173       if (t)
12174         {
12175           /* [dcl.type.elab] If the identifier resolves to a
12176              typedef-name or a template type-parameter, the
12177              elaborated-type-specifier is ill-formed.  */
12178           if (t != TYPE_MAIN_VARIANT (t)
12179               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12180             cp_pedwarn ("using typedef-name `%D' after `%s'",
12181                         TYPE_NAME (t), tag_name (tag_code));
12182           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12183             cp_error ("using template type parameter `%T' after `%s'",
12184                       t, tag_name (tag_code));
12185
12186           ref = t;
12187         }
12188       else
12189         ref = lookup_tag (code, name, b, 0);
12190
12191       if (! ref)
12192         {
12193           /* Try finding it as a type declaration.  If that wins,
12194              use it.  */
12195           ref = lookup_name (name, 1);
12196
12197           if (ref != NULL_TREE
12198               && processing_template_decl
12199               && DECL_CLASS_TEMPLATE_P (ref)
12200               && template_class_depth (current_class_type) == 0)
12201             /* Since GLOBALIZE is true, we're declaring a global
12202                template, so we want this type.  */
12203             ref = DECL_RESULT (ref);
12204
12205           if (ref && TREE_CODE (ref) == TYPE_DECL
12206               && TREE_CODE (TREE_TYPE (ref)) == code)
12207             ref = TREE_TYPE (ref);
12208           else
12209             ref = NULL_TREE;
12210         }
12211
12212       if (ref && current_class_type
12213           && template_class_depth (current_class_type)
12214           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12215         {
12216           /* Since GLOBALIZE is non-zero, we are not looking at a
12217              definition of this tag.  Since, in addition, we are currently
12218              processing a (member) template declaration of a template
12219              class, we must be very careful; consider:
12220
12221                template <class X>
12222                struct S1
12223
12224                template <class U>
12225                struct S2
12226                { template <class V>
12227                friend struct S1; };
12228
12229              Here, the S2::S1 declaration should not be confused with the
12230              outer declaration.  In particular, the inner version should
12231              have a template parameter of level 2, not level 1.  This
12232              would be particularly important if the member declaration
12233              were instead:
12234
12235                template <class V = U> friend struct S1;
12236
12237              say, when we should tsubst into `U' when instantiating
12238              S2.  On the other hand, when presented with:
12239
12240                  template <class T>
12241                  struct S1 {
12242                    template <class U>
12243                    struct S2 {};
12244                    template <class U>
12245                    friend struct S2;
12246                  };
12247
12248               we must find the inner binding eventually.  We
12249               accomplish this by making sure that the new type we
12250               create to represent this declaration has the right
12251               TYPE_CONTEXT.  */
12252           context = TYPE_CONTEXT (ref);
12253           ref = NULL_TREE;
12254         }
12255     }
12256
12257   if (! ref)
12258     {
12259       /* If no such tag is yet defined, create a forward-reference node
12260          and record it as the "definition".
12261          When a real declaration of this type is found,
12262          the forward-reference will be altered into a real type.  */
12263       if (code == ENUMERAL_TYPE)
12264         {
12265           cp_error ("use of enum `%#D' without previous declaration", name);
12266
12267           ref = make_node (ENUMERAL_TYPE);
12268
12269           /* Give the type a default layout like unsigned int
12270              to avoid crashing if it does not get defined.  */
12271           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12272           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12273           TREE_UNSIGNED (ref) = 1;
12274           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12275           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12276           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12277
12278           /* Enable us to recognize when a type is created in class context.
12279              To do nested classes correctly, this should probably be cleared
12280              out when we leave this classes scope.  Currently this in only
12281              done in `start_enum'.  */
12282
12283           pushtag (name, ref, globalize);
12284         }
12285       else
12286         {
12287           struct binding_level *old_b = class_binding_level;
12288
12289           ref = make_aggr_type (code);
12290           TYPE_CONTEXT (ref) = context;
12291
12292 #ifdef NONNESTED_CLASSES
12293           /* Class types don't nest the way enums do.  */
12294           class_binding_level = (struct binding_level *)0;
12295 #endif
12296           pushtag (name, ref, globalize);
12297           class_binding_level = old_b;
12298         }
12299     }
12300   else
12301     {
12302       /* If it no longer looks like a nested type, make sure it's
12303          in global scope.
12304          If it is not an IDENTIFIER, this is not a declaration */
12305       if (b->namespace_p && !class_binding_level
12306           && TREE_CODE (name) == IDENTIFIER_NODE
12307           && IDENTIFIER_NAMESPACE_VALUE (name) == NULL_TREE)
12308         SET_IDENTIFIER_NAMESPACE_VALUE (name, TYPE_NAME (ref));
12309
12310       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12311         redeclare_class_template (ref, current_template_parms);
12312     }
12313
12314   /* Until the type is defined, tentatively accept whatever
12315      structure tag the user hands us.  */
12316   if (TYPE_SIZE (ref) == NULL_TREE
12317       && ref != current_class_type
12318       /* Have to check this, in case we have contradictory tag info.  */
12319       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12320     {
12321       if (tag_code == class_type)
12322         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12323       else if (tag_code == record_type)
12324         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12325     }
12326
12327   TREE_TYPE (ref) = attributes;
12328
12329   return ref;
12330 }
12331
12332 tree
12333 xref_tag_from_type (old, id, globalize)
12334      tree old, id;
12335      int globalize;
12336 {
12337   tree code_type_node;
12338
12339   if (TREE_CODE (old) == RECORD_TYPE)
12340     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12341                       ? class_type_node : record_type_node);
12342   else
12343     code_type_node = union_type_node;
12344
12345   if (id == NULL_TREE)
12346     id = TYPE_IDENTIFIER (old);
12347
12348   return xref_tag (code_type_node, id, globalize);
12349 }
12350
12351 /* REF is a type (named NAME), for which we have just seen some
12352    baseclasses.  BINFO is a list of those baseclasses; the
12353    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12354    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12355    struct, or union.  */
12356
12357 void
12358 xref_basetypes (code_type_node, name, ref, binfo)
12359      tree code_type_node;
12360      tree name, ref;
12361      tree binfo;
12362 {
12363   /* In the declaration `A : X, Y, ... Z' we mark all the types
12364      (A, X, Y, ..., Z) so we can check for duplicates.  */
12365   tree binfos;
12366   tree base;
12367
12368   int i, len;
12369   enum tag_types tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12370
12371   if (tag_code == union_type)
12372     {
12373       cp_error ("derived union `%T' invalid", ref);
12374       return;
12375     }
12376
12377   len = list_length (binfo);
12378
12379   /* First, make sure that any templates in base-classes are
12380      instantiated.  This ensures that if we call ourselves recursively
12381      we do not get confused about which classes are marked and which
12382      are not.  */
12383   for (base = binfo; base; base = TREE_CHAIN (base))
12384     complete_type (TREE_VALUE (base));
12385
12386   SET_CLASSTYPE_MARKED (ref);
12387   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12388
12389   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12390     {
12391       /* The base of a derived struct is public by default.  */
12392       int via_public
12393         = (TREE_PURPOSE (binfo) == access_public_node
12394            || TREE_PURPOSE (binfo) == access_public_virtual_node
12395            || (tag_code != class_type
12396                && (TREE_PURPOSE (binfo) == access_default_node
12397                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12398       int via_protected
12399         = (TREE_PURPOSE (binfo) == access_protected_node
12400            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12401       int via_virtual
12402         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12403            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12404            || TREE_PURPOSE (binfo) == access_public_virtual_node
12405            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12406       tree basetype = TREE_VALUE (binfo);
12407       tree base_binfo;
12408
12409       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12410         basetype = TREE_TYPE (basetype);
12411       if (!basetype
12412           || (TREE_CODE (basetype) != RECORD_TYPE
12413               && TREE_CODE (basetype) != TYPENAME_TYPE
12414               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12415               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12416         {
12417           cp_error ("base type `%T' fails to be a struct or class type",
12418                     TREE_VALUE (binfo));
12419           continue;
12420         }
12421
12422       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12423
12424       /* This code replaces similar code in layout_basetypes.
12425          We put the complete_type first for implicit `typename'.  */
12426       if (TYPE_SIZE (basetype) == NULL_TREE
12427           && ! (current_template_parms && uses_template_parms (basetype)))
12428         {
12429           cp_error ("base class `%T' has incomplete type", basetype);
12430           continue;
12431         }
12432       else
12433         {
12434           if (CLASSTYPE_MARKED (basetype))
12435             {
12436               if (basetype == ref)
12437                 cp_error ("recursive type `%T' undefined", basetype);
12438               else
12439                 cp_error ("duplicate base type `%T' invalid", basetype);
12440               continue;
12441             }
12442
12443           if (TYPE_FOR_JAVA (basetype)
12444               && (current_lang_stack
12445                   == &VARRAY_TREE (current_lang_base, 0)))
12446             TYPE_FOR_JAVA (ref) = 1;
12447
12448           /* Note that the BINFO records which describe individual
12449              inheritances are *not* shared in the lattice!  They
12450              cannot be shared because a given baseclass may be
12451              inherited with different `accessibility' by different
12452              derived classes.  (Each BINFO record describing an
12453              individual inheritance contains flags which say what
12454              the `accessibility' of that particular inheritance is.)  */
12455
12456           base_binfo
12457             = make_binfo (integer_zero_node, basetype,
12458                           CLASS_TYPE_P (basetype)
12459                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12460                           CLASS_TYPE_P (basetype)
12461                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12462
12463           TREE_VEC_ELT (binfos, i) = base_binfo;
12464           TREE_VIA_PUBLIC (base_binfo) = via_public;
12465           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12466           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12467           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12468
12469           /* We need to unshare the binfos now so that lookups during class
12470              definition work.  */
12471           unshare_base_binfos (base_binfo);
12472
12473           SET_CLASSTYPE_MARKED (basetype);
12474
12475           /* We are free to modify these bits because they are meaningless
12476              at top level, and BASETYPE is a top-level type.  */
12477           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12478             {
12479               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12480               /* Converting to a virtual base class requires looking
12481                  up the offset of the virtual base.  */
12482               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12483             }
12484
12485           if (CLASS_TYPE_P (basetype))
12486             {
12487               TYPE_GETS_NEW (ref) |= TYPE_GETS_NEW (basetype);
12488               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12489               /* If the base-class uses multiple inheritance, so do we.  */
12490               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12491                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12492               /* Likewise, if converting to a base of the base may require
12493                  code, then we may need to generate code to convert to a
12494                  base as well.  */
12495               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12496                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12497             }
12498
12499           i += 1;
12500         }
12501     }
12502   if (i)
12503     TREE_VEC_LENGTH (binfos) = i;
12504   else
12505     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12506
12507   if (i > 1)
12508     {
12509       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12510       /* If there is more than one non-empty they cannot be at the same
12511          address.  */
12512       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12513     }
12514
12515   /* Unmark all the types.  */
12516   while (--i >= 0)
12517     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12518   CLEAR_CLASSTYPE_MARKED (ref);
12519
12520   /* Now that we know all the base-classes, set up the list of virtual
12521      bases.  */
12522   CLASSTYPE_VBASECLASSES (ref) = get_vbase_types (ref);
12523 }
12524
12525 \f
12526 /* Begin compiling the definition of an enumeration type.
12527    NAME is its name (or null if anonymous).
12528    Returns the type object, as yet incomplete.
12529    Also records info about it so that build_enumerator
12530    may be used to declare the individual values as they are read.  */
12531
12532 tree
12533 start_enum (name)
12534      tree name;
12535 {
12536   register tree enumtype = NULL_TREE;
12537   struct binding_level *b = current_binding_level;
12538
12539   /* If this is the real definition for a previous forward reference,
12540      fill in the contents in the same object that used to be the
12541      forward reference.  */
12542
12543   if (name != NULL_TREE)
12544     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12545
12546   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12547     {
12548       cp_error ("multiple definition of `%#T'", enumtype);
12549       cp_error_at ("previous definition here", enumtype);
12550       /* Clear out TYPE_VALUES, and start again.  */
12551       TYPE_VALUES (enumtype) = NULL_TREE;
12552     }
12553   else
12554     {
12555       enumtype = make_node (ENUMERAL_TYPE);
12556       pushtag (name, enumtype, 0);
12557     }
12558
12559   if (current_class_type)
12560     TREE_ADDRESSABLE (b->tags) = 1;
12561
12562   GNU_xref_decl (current_function_decl, enumtype);
12563   return enumtype;
12564 }
12565
12566 /* After processing and defining all the values of an enumeration type,
12567    install their decls in the enumeration type and finish it off.
12568    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12569    Returns ENUMTYPE.  */
12570
12571 tree
12572 finish_enum (enumtype)
12573      tree enumtype;
12574 {
12575   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12576   /* Calculate the maximum value of any enumerator in this type.  */
12577
12578   tree values = TYPE_VALUES (enumtype);
12579   if (values)
12580     {
12581       tree pair;
12582
12583       for (pair = values; pair; pair = TREE_CHAIN (pair))
12584         {
12585           tree decl;
12586           tree value;
12587
12588           /* The TREE_VALUE is a CONST_DECL for this enumeration
12589              constant.  */
12590           decl = TREE_VALUE (pair);
12591
12592           /* [dcl.enum]
12593
12594              Following the closing brace of an enum-specifier, each
12595              enumerator has the type of its enumeration.  Prior to the
12596              closing brace, the type of each enumerator is the type of
12597              its initializing value.  */
12598           TREE_TYPE (decl) = enumtype;
12599
12600           /* The DECL_INITIAL will be NULL if we are processing a
12601              template declaration and this enumeration constant had no
12602              explicit initializer.  */
12603           value = DECL_INITIAL (decl);
12604           if (value && !processing_template_decl)
12605             {
12606               /* Set the TREE_TYPE for the VALUE as well.  That's so
12607                  that when we call decl_constant_value we get an
12608                  entity of the right type (but with the constant
12609                  value).  Since we shouldn't ever call
12610                  decl_constant_value on a template type, there's no
12611                  reason to do that when processing_template_decl.
12612                  And, if the expression is something like a
12613                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12614                  wreak havoc on the intended type of the expression.
12615
12616                  Of course, there's also no point in trying to compute
12617                  minimum or maximum values if we're in a template.  */
12618               TREE_TYPE (value) = enumtype;
12619
12620               if (!minnode)
12621                 minnode = maxnode = value;
12622               else if (tree_int_cst_lt (maxnode, value))
12623                 maxnode = value;
12624               else if (tree_int_cst_lt (value, minnode))
12625                 minnode = value;
12626             }
12627
12628           if (processing_template_decl)
12629             /* If this is just a template, leave the CONST_DECL
12630                alone.  That way tsubst_copy will find CONST_DECLs for
12631                CONST_DECLs, and not INTEGER_CSTs.  */
12632             ;
12633           else
12634             /* In the list we're building up, we want the enumeration
12635                values, not the CONST_DECLs.  */
12636             TREE_VALUE (pair) = value;
12637         }
12638     }
12639   else
12640     maxnode = minnode = integer_zero_node;
12641
12642   TYPE_VALUES (enumtype) = nreverse (values);
12643
12644   if (processing_template_decl)
12645     {
12646       tree scope = current_scope ();
12647       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12648         add_tree (build_min (TAG_DEFN, enumtype));
12649     }
12650   else
12651     {
12652       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12653       int lowprec = min_precision (minnode, unsignedp);
12654       int highprec = min_precision (maxnode, unsignedp);
12655       int precision = MAX (lowprec, highprec);
12656       tree tem;
12657
12658       TYPE_SIZE (enumtype) = NULL_TREE;
12659
12660       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12661
12662       TYPE_PRECISION (enumtype) = precision;
12663       if (unsignedp)
12664         fixup_unsigned_type (enumtype);
12665       else
12666         fixup_signed_type (enumtype);
12667
12668       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12669         /* Use the width of the narrowest normal C type which is wide
12670            enough.  */
12671         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12672                                                     (precision, 1));
12673       else
12674         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12675
12676       TYPE_SIZE (enumtype) = 0;
12677       layout_type (enumtype);
12678
12679       /* Fix up all variant types of this enum type.  */
12680       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12681            tem = TYPE_NEXT_VARIANT (tem))
12682         {
12683           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12684           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12685           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12686           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12687           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12688           TYPE_MODE (tem) = TYPE_MODE (enumtype);
12689           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12690           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12691           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12692         }
12693
12694       /* Finish debugging output for this type.  */
12695       rest_of_type_compilation (enumtype, namespace_bindings_p ());
12696     }
12697
12698   return enumtype;
12699 }
12700
12701 /* Build and install a CONST_DECL for an enumeration constant of the
12702    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12703    Assignment of sequential values by default is handled here.  */
12704
12705 void
12706 build_enumerator (name, value, enumtype)
12707      tree name;
12708      tree value;
12709      tree enumtype;
12710 {
12711   tree decl;
12712   tree context;
12713   tree type;
12714   tree values;
12715
12716   /* Remove no-op casts from the value.  */
12717   if (value)
12718     STRIP_TYPE_NOPS (value);
12719
12720   if (! processing_template_decl)
12721     {
12722       /* Validate and default VALUE.  */
12723       if (value != NULL_TREE)
12724         {
12725           if (TREE_READONLY_DECL_P (value))
12726             value = decl_constant_value (value);
12727
12728           if (TREE_CODE (value) == INTEGER_CST)
12729             {
12730               value = default_conversion (value);
12731               constant_expression_warning (value);
12732             }
12733           else
12734             {
12735               cp_error ("enumerator value for `%D' not integer constant", name);
12736               value = NULL_TREE;
12737             }
12738         }
12739
12740       /* Default based on previous value.  */
12741       if (value == NULL_TREE && ! processing_template_decl)
12742         {
12743           tree prev_value;
12744
12745           if (TYPE_VALUES (enumtype))
12746             {
12747               /* The next value is the previous value ... */
12748               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
12749               /* ... plus one.  */
12750               value = build_binary_op_nodefault (PLUS_EXPR,
12751                                                  prev_value,
12752                                                  integer_one_node,
12753                                                  PLUS_EXPR);
12754
12755               if (tree_int_cst_lt (value, prev_value))
12756                 cp_error ("overflow in enumeration values at `%D'", name);
12757             }
12758           else
12759             value = integer_zero_node;
12760         }
12761
12762       /* Remove no-op casts from the value.  */
12763       if (value)
12764         STRIP_TYPE_NOPS (value);
12765 #if 0
12766       /* To fix MAX_VAL enum consts. (bkoz)  */
12767       TREE_TYPE (value) = integer_type_node;
12768 #endif
12769     }
12770
12771   /* We always have to copy here; not all INTEGER_CSTs are unshared.
12772      Even in other cases, we will later (in finish_enum) be setting
12773      the type of VALUE.  But, we don't need to make a copy if this
12774      VALUE is one of the enumeration constants for this same
12775      enumeration type.  */
12776   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
12777     if (TREE_VALUE (values) == value)
12778       break;
12779   /* If we didn't break out of the loop, then we do need a copy.  */
12780   if (!values && value)
12781     value = copy_node (value);
12782
12783   /* C++ associates enums with global, function, or class declarations.  */
12784   context = current_scope ();
12785
12786   /* Build the actual enumeration constant.  Note that the enumeration
12787     constants have the type of their initializers until the
12788     enumeration is complete:
12789
12790       [ dcl.enum ]
12791
12792       Following the closing brace of an enum-specifier, each enumer-
12793       ator has the type of its enumeration.  Prior to the closing
12794       brace, the type of each enumerator is the type of its
12795       initializing value.
12796
12797     In finish_enum we will reset the type.  Of course, if we're
12798     processing a template, there may be no value.   */
12799   type = value ? TREE_TYPE (value) : NULL_TREE;
12800
12801   if (context && context == current_class_type)
12802     /* This enum declaration is local to the class.  We need the full
12803       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
12804     decl = build_lang_decl (CONST_DECL, name, type);
12805   else
12806     /* It's a global enum, or it's local to a function.  (Note local to
12807       a function could mean local to a class method.  */
12808     decl = build_decl (CONST_DECL, name, type);
12809
12810   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
12811   DECL_INITIAL (decl) = value;
12812   TREE_READONLY (decl) = 1;
12813
12814   if (context && context == current_class_type)
12815     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12816       on the TYPE_FIELDS list for `S'.  (That's so that you can say
12817       things like `S::i' later.)  */
12818     finish_member_declaration (decl);
12819   else
12820     {
12821       pushdecl (decl);
12822       GNU_xref_decl (current_function_decl, decl);
12823     }
12824
12825   /* Add this enumeration constant to the list for this type.  */
12826   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
12827 }
12828
12829 \f
12830 static int function_depth;
12831
12832 /* We're defining DECL.  Make sure that it's type is OK.  */
12833
12834 static void
12835 check_function_type (decl)
12836      tree decl;
12837 {
12838   tree fntype = TREE_TYPE (decl);
12839
12840   /* In a function definition, arg types must be complete.  */
12841   require_complete_types_for_parms (current_function_parms);
12842
12843   if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
12844     {
12845       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
12846
12847       /* Make it return void instead, but don't change the
12848          type of the DECL_RESULT, in case we have a named return value.  */
12849       if (TREE_CODE (fntype) == METHOD_TYPE)
12850         {
12851           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
12852           TREE_TYPE (decl)
12853             = build_cplus_method_type (ctype,
12854                                        void_type_node,
12855                                        FUNCTION_ARG_CHAIN (decl));
12856         }
12857       else
12858         TREE_TYPE (decl)
12859           = build_function_type (void_type_node,
12860                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
12861       TREE_TYPE (decl)
12862         = build_exception_variant (fntype,
12863                                    TYPE_RAISES_EXCEPTIONS (fntype));
12864     }
12865   else
12866     abstract_virtuals_error (decl, TREE_TYPE (fntype));
12867 }
12868
12869 /* Create the FUNCTION_DECL for a function definition.
12870    DECLSPECS and DECLARATOR are the parts of the declaration;
12871    they describe the function's name and the type it returns,
12872    but twisted together in a fashion that parallels the syntax of C.
12873
12874    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12875    DECLARATOR is really the DECL for the function we are about to
12876    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12877    indicating that the function is an inline defined in-class, and
12878    SF_EXPAND indicating that we should generate RTL for this
12879    function.
12880
12881    This function creates a binding context for the function body
12882    as well as setting up the FUNCTION_DECL in current_function_decl.
12883
12884    Returns 1 on success.  If the DECLARATOR is not suitable for a function
12885    (it defines a datum instead), we return 0, which tells
12886    yyparse to report a parse error.
12887
12888    For C++, we must first check whether that datum makes any sense.
12889    For example, "class A local_a(1,2);" means that variable local_a
12890    is an aggregate of type A, which should have a constructor
12891    applied to it with the argument list [1, 2].  */
12892
12893 int
12894 start_function (declspecs, declarator, attrs, flags)
12895      tree declspecs, declarator, attrs;
12896      int flags;
12897 {
12898   tree decl1;
12899   tree ctype = NULL_TREE;
12900   tree fntype;
12901   tree restype;
12902   extern int have_extern_spec;
12903   extern int used_extern_spec;
12904   int doing_friend = 0;
12905   struct binding_level *bl;
12906
12907   /* Sanity check.  */
12908   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
12909   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
12910
12911   /* This should only be done once on the top most decl.  */
12912   if (have_extern_spec && !used_extern_spec)
12913     {
12914       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
12915       used_extern_spec = 1;
12916     }
12917
12918   if (flags & SF_PRE_PARSED)
12919     {
12920       decl1 = declarator;
12921
12922       fntype = TREE_TYPE (decl1);
12923       if (TREE_CODE (fntype) == METHOD_TYPE)
12924         ctype = TYPE_METHOD_BASETYPE (fntype);
12925
12926       /* ANSI C++ June 5 1992 WP 11.4.5.  A friend function defined in a
12927          class is in the (lexical) scope of the class in which it is
12928          defined.  */
12929       if (!ctype && DECL_FRIEND_P (decl1))
12930         {
12931           ctype = DECL_CLASS_CONTEXT (decl1);
12932
12933           /* CTYPE could be null here if we're dealing with a template;
12934              for example, `inline friend float foo()' inside a template
12935              will have no CTYPE set.  */
12936           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
12937             ctype = NULL_TREE;
12938           else
12939             doing_friend = 1;
12940         }
12941
12942       last_function_parms = DECL_ARGUMENTS (decl1);
12943       last_function_parm_tags = NULL_TREE;
12944     }
12945   else
12946     {
12947       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
12948       /* If the declarator is not suitable for a function definition,
12949          cause a syntax error.  */
12950       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
12951
12952       fntype = TREE_TYPE (decl1);
12953
12954       restype = TREE_TYPE (fntype);
12955       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
12956         {
12957           cp_error ("semicolon missing after declaration of `%#T'", restype);
12958           shadow_tag (build_expr_list (NULL_TREE, restype));
12959           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
12960           if (TREE_CODE (fntype) == FUNCTION_TYPE)
12961             fntype = build_function_type (integer_type_node,
12962                                           TYPE_ARG_TYPES (fntype));
12963           else
12964             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
12965                                               integer_type_node,
12966                                               TYPE_ARG_TYPES (fntype));
12967           TREE_TYPE (decl1) = fntype;
12968         }
12969
12970       if (TREE_CODE (fntype) == METHOD_TYPE)
12971         ctype = TYPE_METHOD_BASETYPE (fntype);
12972       else if (DECL_MAIN_P (decl1))
12973         {
12974           /* If this doesn't return integer_type, complain.  */
12975           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
12976             {
12977               if (pedantic || warn_return_type)
12978                 pedwarn ("return type for `main' changed to `int'");
12979               TREE_TYPE (decl1) = fntype = default_function_type;
12980             }
12981         }
12982     }
12983
12984   /* Sometimes we don't notice that a function is a static member, and
12985      build a METHOD_TYPE for it.  Fix that up now.  */
12986   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
12987       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
12988     {
12989       revert_static_member_fn (&decl1, NULL, NULL);
12990       last_function_parms = TREE_CHAIN (last_function_parms);
12991       ctype = NULL_TREE;
12992     }
12993
12994   /* Warn if function was previously implicitly declared
12995      (but not if we warned then).  */
12996   if (! warn_implicit
12997       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
12998     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
12999
13000   /* Set up current_class_type, and enter the scope of the class, if
13001      appropriate.  */
13002   if (ctype)
13003     push_nested_class (ctype, 1);
13004   else if (DECL_STATIC_FUNCTION_P (decl1))
13005     push_nested_class (DECL_CONTEXT (decl1), 2);
13006
13007   /* Now that we have entered the scope of the class, we must restore
13008      the bindings for any template parameters surrounding DECL1, if it
13009      is an inline member template.  (Order is important; consider the
13010      case where a template parameter has the same name as a field of
13011      the class.)  It is not until after this point that
13012      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13013   if (flags & SF_INCLASS_INLINE)
13014     maybe_begin_member_template_processing (decl1);
13015
13016   /* Effective C++ rule 15.  See also c_expand_return.  */
13017   if (warn_ecpp
13018       && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
13019       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13020     cp_warning ("`operator=' should return a reference to `*this'");
13021
13022   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13023      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13024   if (!DECL_INITIAL (decl1))
13025     DECL_INITIAL (decl1) = error_mark_node;
13026
13027 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13028   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13029 #endif
13030
13031   /* This function exists in static storage.
13032      (This does not mean `static' in the C sense!)  */
13033   TREE_STATIC (decl1) = 1;
13034
13035   /* We must call push_template_decl after current_class_type is set
13036      up.  (If we are processing inline definitions after exiting a
13037      class scope, current_class_type will be NULL_TREE until set above
13038      by push_nested_class.)  */
13039   if (processing_template_decl)
13040     decl1 = push_template_decl (decl1);
13041
13042   /* We are now in the scope of the function being defined.  */
13043   current_function_decl = decl1;
13044
13045   /* Save the parm names or decls from this function's declarator
13046      where store_parm_decls will find them.  */
13047   current_function_parms = last_function_parms;
13048   current_function_parm_tags = last_function_parm_tags;
13049
13050   /* Make sure the parameter and return types are reasonable.  When
13051      you declare a function, these types can be incomplete, but they
13052      must be complete when you define the function.  */
13053   if (! processing_template_decl)
13054     check_function_type (decl1);
13055
13056   /* Build the return declaration for the function.  */
13057   restype = TREE_TYPE (fntype);
13058   if (!processing_template_decl)
13059     {
13060       if (!DECL_RESULT (decl1))
13061         {
13062           DECL_RESULT (decl1)
13063             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13064           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13065                                       DECL_RESULT (decl1));
13066         }
13067     }
13068   else
13069     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13070     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13071
13072   /* Initialize RTL machinery.  We cannot do this until
13073      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13074      even when processing a template; this is how we get
13075      CFUN set up, and our per-function variables initialized.  */
13076   bl = current_binding_level;
13077   init_function_start (decl1, input_filename, lineno);
13078   current_binding_level = bl;
13079   expanding_p = (flags & SF_EXPAND) != 0;
13080
13081   /* Even though we're inside a function body, we still don't want to
13082      call expand_expr to calculate the size of a variable-sized array.
13083      We haven't necessarily assigned RTL to all variables yet, so it's
13084      not safe to try to expand expressions involving them.  */
13085   immediate_size_expand = 0;
13086   cfun->x_dont_save_pending_sizes_p = 1;
13087
13088   /* If we're building a statement-tree, start the tree now.  */
13089   if (processing_template_decl || !expanding_p)
13090     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13091
13092   /* Let the user know we're compiling this function.  */
13093   if (processing_template_decl || !building_stmt_tree ())
13094     announce_function (decl1);
13095
13096   /* Record the decl so that the function name is defined.
13097      If we already have a decl for this name, and it is a FUNCTION_DECL,
13098      use the old decl.  */
13099   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13100     {
13101       /* A specialization is not used to guide overload resolution.  */
13102       if ((flag_guiding_decls
13103            || !DECL_TEMPLATE_SPECIALIZATION (decl1))
13104           && ! DECL_FUNCTION_MEMBER_P (decl1))
13105         decl1 = pushdecl (decl1);
13106       else
13107         {
13108           /* We need to set the DECL_CONTEXT. */
13109           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13110             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13111           /* And make sure we have enough default args.  */
13112           check_default_args (decl1);
13113         }
13114       DECL_MAIN_VARIANT (decl1) = decl1;
13115       fntype = TREE_TYPE (decl1);
13116     }
13117
13118   /* Reset these in case the call to pushdecl changed them.  */
13119   current_function_decl = decl1;
13120   cfun->decl = decl1;
13121
13122   /* Initialize the per-function data.  */
13123   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13124     {
13125       /* If we already parsed this function, and we're just expanding it
13126          now, restore saved state.  */
13127       struct binding_level *bl = current_binding_level;
13128       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13129       current_binding_level = bl;
13130
13131       /* This function is being processed in whole-function mode; we
13132          already did semantic analysis.  */
13133       cfun->x_whole_function_mode_p = 1;
13134
13135       /* If we decided that we didn't want to inline this function,
13136          make sure the back-end knows that.  */
13137       if (!current_function_cannot_inline)
13138         current_function_cannot_inline = cp_function_chain->cannot_inline;
13139
13140       /* We don't need the saved data anymore.  */
13141       free (DECL_SAVED_FUNCTION_DATA (decl1));
13142       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13143     }
13144   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13145     {
13146       /* We know that this was set up by `grokclassfn'.  We do not
13147          wait until `store_parm_decls', since evil parse errors may
13148          never get us to that point.  Here we keep the consistency
13149          between `current_class_type' and `current_class_ptr'.  */
13150       tree t = DECL_ARGUMENTS (decl1);
13151
13152       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13153                           162);
13154       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13155                           19990811);
13156
13157       cp_function_chain->x_current_class_ref
13158         = build_indirect_ref (t, NULL_PTR);
13159       cp_function_chain->x_current_class_ptr = t;
13160
13161       /* Constructors and destructors need to know whether they're "in
13162          charge" of initializing virtual base classes.  */
13163       if (DECL_DESTRUCTOR_P (decl1))
13164         current_in_charge_parm = TREE_CHAIN (t);
13165       else if (DECL_CONSTRUCTOR_P (decl1)
13166                && TREE_CHAIN (t)
13167                && DECL_ARTIFICIAL (TREE_CHAIN (t))
13168                && (DECL_NAME (TREE_CHAIN (t))
13169                    == in_charge_identifier))
13170         current_in_charge_parm = TREE_CHAIN (t);
13171     }
13172
13173   if (DECL_INTERFACE_KNOWN (decl1))
13174     {
13175       tree ctx = hack_decl_function_context (decl1);
13176
13177       if (DECL_NOT_REALLY_EXTERN (decl1))
13178         DECL_EXTERNAL (decl1) = 0;
13179
13180       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13181           && TREE_PUBLIC (ctx))
13182         /* This is a function in a local class in an extern inline
13183            function.  */
13184         comdat_linkage (decl1);
13185     }
13186   /* If this function belongs to an interface, it is public.
13187      If it belongs to someone else's interface, it is also external.
13188      This only affects inlines and template instantiations.  */
13189   else if (interface_unknown == 0
13190            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13191                || flag_alt_external_templates))
13192     {
13193       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13194           || processing_template_decl)
13195         {
13196           DECL_EXTERNAL (decl1)
13197             = (interface_only
13198                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13199                    && !DECL_VINDEX (decl1)));
13200
13201           /* For WIN32 we also want to put these in linkonce sections.  */
13202           maybe_make_one_only (decl1);
13203         }
13204       else
13205         DECL_EXTERNAL (decl1) = 0;
13206       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13207       DECL_INTERFACE_KNOWN (decl1) = 1;
13208     }
13209   else if (interface_unknown && interface_only
13210            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13211                || flag_alt_external_templates))
13212     {
13213       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13214          interface, we will have interface_only set but not
13215          interface_known.  In that case, we don't want to use the normal
13216          heuristics because someone will supply a #pragma implementation
13217          elsewhere, and deducing it here would produce a conflict.  */
13218       comdat_linkage (decl1);
13219       DECL_EXTERNAL (decl1) = 0;
13220       DECL_INTERFACE_KNOWN (decl1) = 1;
13221       DECL_DEFER_OUTPUT (decl1) = 1;
13222     }
13223   else
13224     {
13225       /* This is a definition, not a reference.
13226          So clear DECL_EXTERNAL.  */
13227       DECL_EXTERNAL (decl1) = 0;
13228
13229       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13230           && ! DECL_INTERFACE_KNOWN (decl1)
13231           /* Don't try to defer nested functions for now.  */
13232           && ! hack_decl_function_context (decl1))
13233         DECL_DEFER_OUTPUT (decl1) = 1;
13234       else
13235         DECL_INTERFACE_KNOWN (decl1) = 1;
13236     }
13237
13238   if (doing_semantic_analysis_p ())
13239     {
13240       pushlevel (0);
13241       current_binding_level->parm_flag = 1;
13242     }
13243
13244   if (attrs)
13245     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13246
13247   if (!building_stmt_tree ())
13248     {
13249       GNU_xref_function (decl1, current_function_parms);
13250       make_function_rtl (decl1);
13251     }
13252
13253   /* Promote the value to int before returning it.  */
13254   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13255     restype = type_promotes_to (restype);
13256
13257   /* If this fcn was already referenced via a block-scope `extern' decl
13258      (or an implicit decl), propagate certain information about the usage.  */
13259   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13260     TREE_ADDRESSABLE (decl1) = 1;
13261
13262   if (DECL_RESULT (decl1) == NULL_TREE)
13263     {
13264       DECL_RESULT (decl1)
13265         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13266       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13267       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13268     }
13269
13270   ++function_depth;
13271
13272   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
13273       && DECL_LANGUAGE (decl1) == lang_cplusplus)
13274     {
13275       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13276       DECL_CONTEXT (dtor_label) = current_function_decl;
13277     }
13278   else if (DECL_CONSTRUCTOR_P (decl1))
13279     {
13280       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13281       DECL_CONTEXT (ctor_label) = current_function_decl;
13282     }
13283
13284   return 1;
13285 }
13286 \f
13287 /* Called after store_parm_decls for a function-try-block.  */
13288
13289 void
13290 expand_start_early_try_stmts ()
13291 {
13292   expand_start_try_stmts ();
13293 }
13294
13295 /* Store the parameter declarations into the current function declaration.
13296    This is called after parsing the parameter declarations, before
13297    digesting the body of the function.
13298
13299    Also install to binding contour return value identifier, if any.  */
13300
13301 void
13302 store_parm_decls ()
13303 {
13304   register tree fndecl = current_function_decl;
13305   register tree parm;
13306   int parms_have_cleanups = 0;
13307   tree cleanups = NULL_TREE;
13308
13309   /* This is a list of types declared among parms in a prototype.  */
13310   tree parmtags = current_function_parm_tags;
13311
13312   /* This is a chain of any other decls that came in among the parm
13313      declarations.  If a parm is declared with  enum {foo, bar} x;
13314      then CONST_DECLs for foo and bar are put here.  */
13315   tree nonparms = NULL_TREE;
13316
13317   /* Create a binding level for the parms.  */
13318   if (!building_stmt_tree ())
13319     expand_start_bindings (2);
13320
13321   if (current_function_parms)
13322     {
13323       /* This case is when the function was defined with an ANSI prototype.
13324          The parms already have decls, so we need not do anything here
13325          except record them as in effect
13326          and complain if any redundant old-style parm decls were written.  */
13327
13328       tree specparms = current_function_parms;
13329       tree next;
13330
13331       if (doing_semantic_analysis_p ())
13332         {
13333           /* Must clear this because it might contain TYPE_DECLs declared
13334              at class level.  */
13335           storedecls (NULL_TREE);
13336
13337           /* If we're doing semantic analysis, then we'll call pushdecl
13338              for each of these.  We must do them in reverse order so that
13339              they end in the correct forward order.  */
13340           specparms = nreverse (specparms);
13341         }
13342
13343       for (parm = specparms; parm; parm = next)
13344         {
13345           next = TREE_CHAIN (parm);
13346           if (TREE_CODE (parm) == PARM_DECL)
13347             {
13348               tree type = TREE_TYPE (parm);
13349
13350               if (doing_semantic_analysis_p ())
13351                 {
13352                   tree cleanup;
13353
13354                   if (DECL_NAME (parm) == NULL_TREE
13355                       || TREE_CODE (parm) != VOID_TYPE)
13356                     pushdecl (parm);
13357                   else
13358                     cp_error ("parameter `%D' declared void", parm);
13359
13360                   cleanup = maybe_build_cleanup (parm);
13361
13362                   if (cleanup)
13363                     cleanups = tree_cons (parm, cleanup, cleanups);
13364                 }
13365               else if (type != error_mark_node
13366                        && TYPE_NEEDS_DESTRUCTOR (type))
13367                 parms_have_cleanups = 1;
13368             }
13369           else
13370             {
13371               /* If we find an enum constant or a type tag,
13372                  put it aside for the moment.  */
13373               TREE_CHAIN (parm) = NULL_TREE;
13374               nonparms = chainon (nonparms, parm);
13375             }
13376         }
13377
13378       if (doing_semantic_analysis_p ())
13379         {
13380           /* Get the decls in their original chain order
13381              and record in the function.  This is all and only the
13382              PARM_DECLs that were pushed into scope by the loop above.  */
13383           DECL_ARGUMENTS (fndecl) = getdecls ();
13384           storetags (chainon (parmtags, gettags ()));
13385         }
13386     }
13387   else
13388     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13389
13390   /* Now store the final chain of decls for the arguments
13391      as the decl-chain of the current lexical scope.
13392      Put the enumerators in as well, at the front so that
13393      DECL_ARGUMENTS is not modified.  */
13394   if (doing_semantic_analysis_p ())
13395     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13396
13397   /* Initialize the RTL code for the function.  */
13398   DECL_SAVED_INSNS (fndecl) = 0;
13399   if (! building_stmt_tree ())
13400     expand_function_start (fndecl, parms_have_cleanups);
13401
13402   current_function_parms_stored = 1;
13403
13404   /* If this function is `main', emit a call to `__main'
13405      to run global initializers, etc.  */
13406   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13407     expand_main_function ();
13408
13409   /* Now that we have initialized the parms, we can start their
13410      cleanups.  We cannot do this before, since expand_decl_cleanup
13411      should not be called before the parm can be used.  */
13412   while (cleanups)
13413     {
13414       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13415                            TREE_VALUE (cleanups));
13416       cleanups = TREE_CHAIN (cleanups);
13417     }
13418
13419   /* Create a binding contour which can be used to catch
13420      cleanup-generated temporaries.  Also, if the return value needs or
13421      has initialization, deal with that now.  */
13422   if (parms_have_cleanups)
13423     {
13424       pushlevel (0);
13425       if (!building_stmt_tree ())
13426         expand_start_bindings (2);
13427     }
13428
13429   /* Do the starting of the exception specifications, if we have any.  */
13430   if (flag_exceptions && !processing_template_decl
13431       && building_stmt_tree ()
13432       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13433     current_eh_spec_try_block = expand_start_eh_spec ();
13434 }
13435
13436 /* Bind a name and initialization to the return value of
13437    the current function.  */
13438
13439 void
13440 store_return_init (decl)
13441      tree decl;
13442 {
13443   /* If this named return value comes in a register, put it in a
13444      pseudo-register.  */
13445   if (DECL_REGISTER (decl))
13446     {
13447       original_result_rtx = DECL_RTL (decl);
13448       /* Note that the mode of the old DECL_RTL may be wider than the
13449          mode of DECL_RESULT, depending on the calling conventions for
13450          the processor.  For example, on the Alpha, a 32-bit integer
13451          is returned in a DImode register -- the DECL_RESULT has
13452          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
13453          here, we use the mode the back-end has already assigned for
13454          the return value.  */
13455       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13456     }
13457 }
13458
13459 \f
13460 /* We have finished doing semantic analysis on DECL, but have not yet
13461    generated RTL for its body.  Save away our current state, so that
13462    when we want to generate RTL later we know what to do.  */
13463
13464 static void
13465 save_function_data (decl)
13466      tree decl;
13467 {
13468   struct language_function *f;
13469
13470   /* Save the language-specific per-function data so that we can
13471      get it back when we really expand this function.  */
13472   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13473                       19990908);
13474
13475   /* Make a copy.  */
13476   f = ((struct language_function *)
13477        xmalloc (sizeof (struct language_function)));
13478   bcopy ((char *) cp_function_chain, (char *) f,
13479          sizeof (struct language_function));
13480   DECL_SAVED_FUNCTION_DATA (decl) = f;
13481
13482   /* Clear out the bits we don't need.  */
13483   f->x_base_init_list = NULL_TREE;
13484   f->x_member_init_list = NULL_TREE;
13485   f->x_stmt_tree.x_last_stmt = NULL_TREE;
13486   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
13487   f->x_result_rtx = NULL_RTX;
13488   f->x_named_label_uses = NULL;
13489   f->bindings = NULL;
13490
13491   /* When we get back here again, we will be expanding.  */
13492   f->x_expanding_p = 1;
13493
13494   /* If we've already decided that we cannot inline this function, we
13495      must remember that fact when we actually go to expand the
13496      function.  */
13497   f->cannot_inline = current_function_cannot_inline;
13498 }
13499
13500 /* At the end of every constructor we generate to code to return
13501    `this'.  Do that now.  */
13502
13503 static void
13504 finish_constructor_body ()
13505 {
13506   /* Any return from a constructor will end up here.  */
13507   add_tree (build_min_nt (LABEL_STMT, ctor_label));
13508
13509   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13510      generate the return, rather than a goto to CTOR_LABEL.  */
13511   ctor_label = NULL_TREE;
13512   /* In check_return_expr we translate an empty return from a
13513      constructor to a return of `this'.  */
13514   finish_return_stmt (NULL_TREE);
13515   /* Mark the end of the constructor.  */
13516   add_tree (build_min_nt (CTOR_STMT));
13517 }
13518
13519 /* At the end of every destructor we generate code to restore virtual
13520    function tables to the values desired by base classes and to call
13521    to base class destructors.  Do that now.  */
13522
13523 static void
13524 finish_destructor_body ()
13525 {
13526   tree compound_stmt;
13527   tree in_charge;
13528   tree virtual_size;
13529   tree exprstmt;
13530
13531   /* Create a block to contain all the extra code.  */
13532   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13533
13534   /* Any return from a destructor will end up here.  */
13535   add_tree (build_min_nt (LABEL_STMT, dtor_label));
13536
13537   /* Generate the code to call destructor on base class.  If this
13538      destructor belongs to a class with virtual functions, then set
13539      the virtual function table pointer to represent the type of our
13540      base class.  */
13541
13542   /* This side-effect makes call to `build_delete' generate the code
13543      we have to have at the end of this destructor.  `build_delete'
13544      will set the flag again.  */
13545   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13546
13547   /* These are two cases where we cannot delegate deletion.  */
13548   if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
13549       || TYPE_GETS_REG_DELETE (current_class_type))
13550     in_charge = integer_zero_node;
13551   else
13552     in_charge = current_in_charge_parm;
13553
13554   exprstmt = build_delete (current_class_type,
13555                            current_class_ref,
13556                            in_charge,
13557                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13558                            0);
13559
13560   if (exprstmt != error_mark_node
13561       && (TREE_CODE (exprstmt) != NOP_EXPR
13562           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13563           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13564     {
13565       if (exprstmt != void_zero_node)
13566         /* Don't call `expand_expr_stmt' if we're not going to do
13567            anything, since -Wall will give a diagnostic.  */
13568         finish_expr_stmt (exprstmt);
13569
13570       /* Run destructors for all virtual baseclasses.  */
13571       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13572         {
13573           tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
13574           tree if_stmt = begin_if_stmt ();
13575           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13576                                       current_in_charge_parm,
13577                                       integer_two_node),
13578                                if_stmt);
13579
13580           while (vbases)
13581             {
13582               if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases)))
13583                 {
13584                   tree vb = get_vbase
13585                     (BINFO_TYPE (vbases),
13586                      TYPE_BINFO (current_class_type));
13587                   finish_expr_stmt
13588                     (build_scoped_method_call
13589                      (current_class_ref, vb, dtor_identifier,
13590                       build_expr_list (NULL_TREE, integer_zero_node)));
13591                 }
13592               vbases = TREE_CHAIN (vbases);
13593             }
13594
13595           finish_then_clause (if_stmt);
13596           finish_if_stmt ();
13597         }
13598     }
13599
13600   virtual_size = c_sizeof (current_class_type);
13601
13602   /* At the end, call delete if that's what's requested.  */
13603
13604   /* FDIS sez: At the point of definition of a virtual destructor
13605      (including an implicit definition), non-placement operator delete
13606      shall be looked up in the scope of the destructor's class and if
13607      found shall be accessible and unambiguous.
13608
13609      This is somewhat unclear, but I take it to mean that if the class
13610      only defines placement deletes we don't do anything here.  So we
13611      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13612      they ever try to delete one of these.  */
13613   if (TYPE_GETS_REG_DELETE (current_class_type)
13614       || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13615     {
13616       tree if_stmt;
13617
13618       exprstmt = build_op_delete_call
13619         (DELETE_EXPR, current_class_ptr, virtual_size,
13620          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13621
13622       if_stmt = begin_if_stmt ();
13623       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13624                                   current_in_charge_parm,
13625                                   integer_one_node),
13626                            if_stmt);
13627       finish_expr_stmt (exprstmt);
13628       finish_then_clause (if_stmt);
13629       finish_if_stmt ();
13630     }
13631
13632   /* Close the block we started above.  */
13633   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13634 }
13635
13636 /* Finish up a function declaration and compile that function
13637    all the way to assembler language output.  The free the storage
13638    for the function definition.
13639
13640    This is called after parsing the body of the function definition.
13641    LINENO is the current line number.
13642
13643    FLAGS is a bitwise or of the following values:
13644      1 - CALL_POPLEVEL
13645        An extra call to poplevel (and expand_end_bindings) must be
13646        made to take care of the binding contour for the base
13647        initializers.  This is only relevant for constructors.
13648      2 - INCLASS_INLINE
13649        We just finished processing the body of an in-class inline
13650        function definition.  (This processing will have taken place
13651        after the class definition is complete.)  */
13652
13653 tree
13654 finish_function (lineno, flags)
13655      int lineno;
13656      int flags;
13657 {
13658   register tree fndecl = current_function_decl;
13659   tree fntype, ctype = NULL_TREE;
13660   /* Label to use if this function is supposed to return a value.  */
13661   tree no_return_label = NULL_TREE;
13662   int call_poplevel = (flags & 1) != 0;
13663   int inclass_inline = (flags & 2) != 0;
13664   int expand_p;
13665   int nested;
13666
13667   /* When we get some parse errors, we can end up without a
13668      current_function_decl, so cope.  */
13669   if (fndecl == NULL_TREE)
13670     return error_mark_node;
13671
13672   nested = function_depth > 1;
13673   fntype = TREE_TYPE (fndecl);
13674
13675   /*  TREE_READONLY (fndecl) = 1;
13676       This caused &foo to be of type ptr-to-const-function
13677       which then got a warning when stored in a ptr-to-function variable.  */
13678
13679   /* This happens on strange parse errors.  */
13680   if (! current_function_parms_stored)
13681     {
13682       call_poplevel = 0;
13683       store_parm_decls ();
13684     }
13685
13686   if (building_stmt_tree ())
13687     {
13688       if (DECL_CONSTRUCTOR_P (fndecl))
13689         {
13690           finish_constructor_body ();
13691           if (call_poplevel)
13692             do_poplevel ();
13693         }
13694       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13695         finish_destructor_body ();
13696       else if (DECL_MAIN_P (fndecl))
13697         {
13698           /* Make it so that `main' always returns 0 by default.  */
13699 #ifdef VMS
13700           finish_return_stmt (integer_one_node);
13701 #else
13702           finish_return_stmt (integer_zero_node);
13703 #endif
13704         }
13705
13706       /* Finish dealing with exception specifiers.  */
13707       if (flag_exceptions && !processing_template_decl
13708           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13709         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13710                             (TREE_TYPE (current_function_decl)),
13711                             current_eh_spec_try_block);
13712     }
13713   else
13714     {
13715 #if 0
13716       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13717         {
13718           /* Keep this code around in case we later want to control debug info
13719              based on whether a type is "used".  (jason 1999-11-11) */
13720
13721           tree ttype = target_type (fntype);
13722           tree parmdecl;
13723
13724           if (IS_AGGR_TYPE (ttype))
13725             /* Let debugger know it should output info for this type.  */
13726             note_debug_info_needed (ttype);
13727
13728           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
13729             {
13730               ttype = target_type (TREE_TYPE (parmdecl));
13731               if (IS_AGGR_TYPE (ttype))
13732                 /* Let debugger know it should output info for this type.  */
13733                 note_debug_info_needed (ttype);
13734             }
13735         }
13736 #endif
13737
13738       /* Clean house because we will need to reorder insns here.  */
13739       do_pending_stack_adjust ();
13740
13741       if (dtor_label)
13742         ;
13743       else if (DECL_CONSTRUCTOR_P (fndecl))
13744         {
13745           if (call_poplevel)
13746             do_poplevel ();
13747         }
13748       else if (return_label != NULL_RTX
13749                && flag_this_is_variable <= 0
13750                && current_function_return_value == NULL_TREE
13751                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
13752         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13753
13754       if (flag_exceptions)
13755         expand_exception_blocks ();
13756
13757       /* If this function is supposed to return a value, ensure that
13758          we do not fall into the cleanups by mistake.  The end of our
13759          function will look like this:
13760
13761          user code (may have return stmt somewhere)
13762          goto no_return_label
13763          cleanup_label:
13764          cleanups
13765          goto return_label
13766          no_return_label:
13767          NOTE_INSN_FUNCTION_END
13768          return_label:
13769          things for return
13770
13771          If the user omits a return stmt in the USER CODE section, we
13772          will have a control path which reaches NOTE_INSN_FUNCTION_END.
13773          Otherwise, we won't.  */
13774       if (no_return_label)
13775         {
13776           DECL_CONTEXT (no_return_label) = fndecl;
13777           DECL_INITIAL (no_return_label) = error_mark_node;
13778           DECL_SOURCE_FILE (no_return_label) = input_filename;
13779           DECL_SOURCE_LINE (no_return_label) = lineno;
13780           expand_goto (no_return_label);
13781         }
13782
13783       if (cleanup_label)
13784         {
13785           /* Remove the binding contour which is used
13786              to catch cleanup-generated temporaries.  */
13787           expand_end_bindings (0, 0, 0);
13788           poplevel (0, 0, 0);
13789
13790           /* Emit label at beginning of cleanup code for parameters.  */
13791           emit_label (cleanup_label);
13792         }
13793
13794       /* Get return value into register if that's where it's supposed
13795          to be.  */
13796       if (original_result_rtx)
13797         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
13798
13799       /* Finish building code that will trigger warnings if users forget
13800          to make their functions return values.  */
13801       if (no_return_label || cleanup_label)
13802         emit_jump (return_label);
13803       if (no_return_label)
13804         {
13805           /* We don't need to call `expand_*_return' here because we
13806              don't need any cleanups here--this path of code is only
13807              for error checking purposes.  */
13808           expand_label (no_return_label);
13809         }
13810
13811       /* We hard-wired immediate_size_expand to zero in
13812          start_function.  Expand_function_end will decrement this
13813          variable.  So, we set the variable to one here, so that after
13814          the decrement it will remain zero.  */
13815       immediate_size_expand = 1;
13816
13817       /* Generate rtl for function exit.  */
13818       expand_function_end (input_filename, lineno, 1);
13819     }
13820
13821   /* We have to save this value here in case
13822      maybe_end_member_template_processing decides to pop all the
13823      template parameters.  */
13824   expand_p = !building_stmt_tree ();
13825
13826   /* If we're saving up tree structure, tie off the function now.  */
13827   if (!expand_p)
13828     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13829
13830   /* This must come after expand_function_end because cleanups might
13831      have declarations (from inline functions) that need to go into
13832      this function's blocks.  */
13833   if (doing_semantic_analysis_p ())
13834     {
13835       if (current_binding_level->parm_flag != 1)
13836         my_friendly_abort (122);
13837       poplevel (1, 0, 1);
13838     }
13839
13840   /* Remember that we were in class scope.  */
13841   if (current_class_name)
13842     ctype = current_class_type;
13843
13844   /* Must mark the RESULT_DECL as being in this function.  */
13845   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13846
13847   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13848      to the FUNCTION_DECL node itself.  */
13849   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13850
13851   /* Save away current state, if appropriate.  */
13852   if (!expanding_p && !processing_template_decl)
13853     save_function_data (fndecl);
13854
13855   /* If this function calls `setjmp' it cannot be inlined.  When
13856      `longjmp' is called it is not guaranteed to restore the value of
13857      local variables that have been modified since the call to
13858      `setjmp'.  So, if were to inline this function into some caller
13859      `c', then when we `longjmp', we might not restore all variables
13860      in `c'.  (It might seem, at first blush, that there's no way for
13861      this function to modify local variables in `c', but their
13862      addresses may have been stored somewhere accessible to this
13863      function.)  */
13864   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
13865     DECL_UNINLINABLE (fndecl) = 1;
13866
13867   if (expand_p)
13868     {
13869       int returns_null;
13870       int returns_value;
13871       int saved_flag_keep_inline_functions =
13872         flag_keep_inline_functions;
13873
13874       /* So we can tell if jump_optimize sets it to 1.  */
13875       can_reach_end = 0;
13876
13877       if (DECL_CONTEXT (fndecl) != NULL_TREE
13878           && hack_decl_function_context (fndecl))
13879         /* Trick rest_of_compilation into not deferring output of this
13880            function, even if it is inline, since the rtl_obstack for
13881            this function is the function_obstack of the enclosing
13882            function and will be deallocated when the enclosing
13883            function is gone.  See save_tree_status.  */
13884         flag_keep_inline_functions = 1;
13885
13886       /* Before we call rest_of_compilation (which will pop the
13887          CURRENT_FUNCTION), we must save these values.  */
13888       returns_null = current_function_returns_null;
13889       returns_value = current_function_returns_value;
13890
13891       /* If this is a nested function (like a template instantiation
13892          that we're compiling in the midst of compiling something
13893          else), push a new GC context.  That will keep local variables
13894          on the stack from being collected while we're doing the
13895          compilation of this function.  */
13896       if (function_depth > 1)
13897         ggc_push_context ();
13898
13899       /* Run the optimizers and output the assembler code for this
13900          function.  */
13901       if (DECL_ARTIFICIAL (fndecl))
13902         {
13903           /* Do we really *want* to inline this synthesized method?  */
13904
13905           int save_fif = flag_inline_functions;
13906           flag_inline_functions = 1;
13907
13908           /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13909              will check our size.  */
13910           DECL_INLINE (fndecl) = 0;
13911
13912           rest_of_compilation (fndecl);
13913           flag_inline_functions = save_fif;
13914         }
13915       else
13916         rest_of_compilation (fndecl);
13917
13918       /* Undo the call to ggc_push_context above.  */
13919       if (function_depth > 1)
13920         ggc_pop_context ();
13921
13922       flag_keep_inline_functions = saved_flag_keep_inline_functions;
13923
13924       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
13925         {
13926           /* Set DECL_EXTERNAL so that assemble_external will be called as
13927              necessary.  We'll clear it again in finish_file.  */
13928           if (! DECL_EXTERNAL (fndecl))
13929             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
13930           DECL_EXTERNAL (fndecl) = 1;
13931           mark_inline_for_output (fndecl);
13932         }
13933
13934 #if 0
13935       /* Keep this code around in case we later want to control debug info
13936          based on whether a type is "used".  (jason 1999-11-11) */
13937
13938       if (ctype && TREE_ASM_WRITTEN (fndecl))
13939         note_debug_info_needed (ctype);
13940 #endif
13941
13942       returns_null |= can_reach_end;
13943
13944       /* Since we don't normally go through c_expand_return for constructors,
13945          this normally gets the wrong value.
13946          Also, named return values have their return codes emitted after
13947          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
13948       if (DECL_CONSTRUCTOR_P (fndecl)
13949           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
13950         returns_null = 0;
13951
13952       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
13953         cp_warning ("`noreturn' function `%D' does return", fndecl);
13954       else if ((warn_return_type || pedantic)
13955                && returns_null
13956                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
13957         {
13958           /* If this function returns non-void and control can drop through,
13959              complain.  */
13960           cp_warning ("control reaches end of non-void function `%D'", fndecl);
13961         }
13962       /* With just -W, complain only if function returns both with
13963          and without a value.  */
13964       else if (extra_warnings && returns_value && returns_null)
13965         warning ("this function may return with or without a value");
13966     }
13967   else
13968     {
13969       /* Clear out memory we no longer need.  */
13970       free_after_parsing (cfun);
13971       /* Since we never call rest_of_compilation, we never clear
13972          CFUN.  Do so explicitly.  */
13973       free_after_compilation (cfun);
13974       cfun = NULL;
13975     }
13976
13977   /* If this is a in-class inline definition, we may have to pop the
13978      bindings for the template parameters that we added in
13979      maybe_begin_member_template_processing when start_function was
13980      called.  */
13981   if (inclass_inline)
13982     maybe_end_member_template_processing ();
13983
13984   /* Leave the scope of the class.  */
13985   if (ctype)
13986     pop_nested_class ();
13987
13988   --function_depth;
13989
13990   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
13991       && !(flag_inline_trees && DECL_INLINE (fndecl)))
13992     {
13993       tree t;
13994
13995       /* Stop pointing to the local nodes about to be freed.  */
13996       /* But DECL_INITIAL must remain nonzero so we know this
13997          was an actual function definition.  */
13998       DECL_INITIAL (fndecl) = error_mark_node;
13999       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14000         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14001     }
14002
14003   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14004     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14005   if (DECL_STATIC_DESTRUCTOR (fndecl))
14006     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14007
14008   /* Clean up.  */
14009   if (! nested)
14010     {
14011       /* Let the error reporting routines know that we're outside a
14012          function.  For a nested function, this value is used in
14013          pop_cp_function_context and then reset via pop_function_context.  */
14014       current_function_decl = NULL_TREE;
14015       /* We don't really care about obstacks, but the middle-end
14016          sometimes cares on what obstck things are located.  */
14017       permanent_allocation (1);
14018     }
14019
14020   return fndecl;
14021 }
14022 \f
14023 /* Create the FUNCTION_DECL for a function definition.
14024    DECLSPECS and DECLARATOR are the parts of the declaration;
14025    they describe the return type and the name of the function,
14026    but twisted together in a fashion that parallels the syntax of C.
14027
14028    This function creates a binding context for the function body
14029    as well as setting up the FUNCTION_DECL in current_function_decl.
14030
14031    Returns a FUNCTION_DECL on success.
14032
14033    If the DECLARATOR is not suitable for a function (it defines a datum
14034    instead), we return 0, which tells yyparse to report a parse error.
14035
14036    May return void_type_node indicating that this method is actually
14037    a friend.  See grokfield for more details.
14038
14039    Came here with a `.pushlevel' .
14040
14041    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14042    CHANGES TO CODE IN `grokfield'.  */
14043
14044 tree
14045 start_method (declspecs, declarator, attrlist)
14046      tree declarator, declspecs, attrlist;
14047 {
14048   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14049                                 attrlist);
14050
14051   /* Something too ugly to handle.  */
14052   if (fndecl == NULL_TREE)
14053     return NULL_TREE;
14054
14055   /* Pass friends other than inline friend functions back.  */
14056   if (fndecl == void_type_node)
14057     return fndecl;
14058
14059   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14060     /* Not a function, tell parser to report parse error.  */
14061     return NULL_TREE;
14062
14063   if (DECL_IN_AGGR_P (fndecl))
14064     {
14065       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14066         {
14067           if (DECL_CONTEXT (fndecl)
14068               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14069             cp_error ("`%D' is already defined in class %s", fndecl,
14070                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14071         }
14072       return void_type_node;
14073     }
14074
14075   check_template_shadow (fndecl);
14076
14077   DECL_THIS_INLINE (fndecl) = 1;
14078
14079   if (flag_default_inline)
14080     DECL_INLINE (fndecl) = 1;
14081
14082   /* We process method specializations in finish_struct_1.  */
14083   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14084     fndecl = push_template_decl (fndecl);
14085
14086   /* We read in the parameters on the maybepermanent_obstack,
14087      but we won't be getting back to them until after we
14088      may have clobbered them.  So the call to preserve_data
14089      will keep them safe.  */
14090   preserve_data ();
14091
14092   if (! DECL_FRIEND_P (fndecl))
14093     {
14094       if (TREE_CHAIN (fndecl))
14095         {
14096           fndecl = copy_node (fndecl);
14097           TREE_CHAIN (fndecl) = NULL_TREE;
14098         }
14099
14100       if (DECL_CONSTRUCTOR_P (fndecl))
14101         {
14102           if (! grok_ctor_properties (current_class_type, fndecl))
14103             return void_type_node;
14104         }
14105       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14106         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14107     }
14108
14109   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14110
14111   /* Make a place for the parms */
14112   pushlevel (0);
14113   current_binding_level->parm_flag = 1;
14114
14115   DECL_IN_AGGR_P (fndecl) = 1;
14116   return fndecl;
14117 }
14118
14119 /* Go through the motions of finishing a function definition.
14120    We don't compile this method until after the whole class has
14121    been processed.
14122
14123    FINISH_METHOD must return something that looks as though it
14124    came from GROKFIELD (since we are defining a method, after all).
14125
14126    This is called after parsing the body of the function definition.
14127    STMTS is the chain of statements that makes up the function body.
14128
14129    DECL is the ..._DECL that `start_method' provided.  */
14130
14131 tree
14132 finish_method (decl)
14133      tree decl;
14134 {
14135   register tree fndecl = decl;
14136   tree old_initial;
14137
14138   register tree link;
14139
14140   if (decl == void_type_node)
14141     return decl;
14142
14143   old_initial = DECL_INITIAL (fndecl);
14144
14145   /* Undo the level for the parms (from start_method).
14146      This is like poplevel, but it causes nothing to be
14147      saved.  Saving information here confuses symbol-table
14148      output routines.  Besides, this information will
14149      be correctly output when this method is actually
14150      compiled.  */
14151
14152   /* Clear out the meanings of the local variables of this level;
14153      also record in each decl which block it belongs to.  */
14154
14155   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14156     {
14157       if (DECL_NAME (link) != NULL_TREE)
14158         pop_binding (DECL_NAME (link), link);
14159       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14160       DECL_CONTEXT (link) = NULL_TREE;
14161     }
14162
14163   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14164                       (HOST_WIDE_INT) current_binding_level->level_chain,
14165                       current_binding_level->parm_flag,
14166                       current_binding_level->keep);
14167
14168   poplevel (0, 0, 0);
14169
14170   DECL_INITIAL (fndecl) = old_initial;
14171
14172   /* We used to check if the context of FNDECL was different from
14173      current_class_type as another way to get inside here.  This didn't work
14174      for String.cc in libg++.  */
14175   if (DECL_FRIEND_P (fndecl))
14176     {
14177       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14178         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14179       decl = void_type_node;
14180     }
14181
14182   return decl;
14183 }
14184 \f
14185 /* Called when a new struct TYPE is defined.
14186    If this structure or union completes the type of any previous
14187    variable declaration, lay it out and output its rtl.  */
14188
14189 void
14190 hack_incomplete_structures (type)
14191      tree type;
14192 {
14193   tree *list;
14194
14195   if (current_binding_level->incomplete == NULL_TREE)
14196     return;
14197
14198   if (!type) /* Don't do this for class templates.  */
14199     return;
14200
14201   for (list = &current_binding_level->incomplete; *list; )
14202     {
14203       tree decl = TREE_VALUE (*list);
14204       if ((decl && TREE_TYPE (decl) == type)
14205           || (TREE_TYPE (decl)
14206               && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14207               && TREE_TYPE (TREE_TYPE (decl)) == type))
14208         {
14209           int toplevel = toplevel_bindings_p ();
14210           if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14211               && TREE_TYPE (TREE_TYPE (decl)) == type)
14212             layout_type (TREE_TYPE (decl));
14213           layout_decl (decl, 0);
14214           rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14215           if (! toplevel)
14216             {
14217               tree cleanup;
14218               expand_decl (decl);
14219               cleanup = maybe_build_cleanup (decl);
14220               expand_decl_init (decl);
14221               if (! expand_decl_cleanup (decl, cleanup))
14222                 cp_error ("parser lost in parsing declaration of `%D'",
14223                           decl);
14224             }
14225           *list = TREE_CHAIN (*list);
14226         }
14227       else
14228         list = &TREE_CHAIN (*list);
14229     }
14230 }
14231
14232 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14233    See build_delete for information about AUTO_DELETE.
14234
14235    Don't build these on the momentary obstack; they must live
14236    the life of the binding contour.  */
14237
14238 static tree
14239 maybe_build_cleanup_1 (decl, auto_delete)
14240      tree decl, auto_delete;
14241 {
14242   tree type = TREE_TYPE (decl);
14243   if (type != error_mark_node && TYPE_NEEDS_DESTRUCTOR (type))
14244     {
14245       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14246       tree rval;
14247
14248       if (TREE_CODE (type) == ARRAY_TYPE)
14249         rval = decl;
14250       else
14251         {
14252           mark_addressable (decl);
14253           rval = build_unary_op (ADDR_EXPR, decl, 0);
14254         }
14255
14256       /* Optimize for space over speed here.  */
14257       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14258           || flag_expensive_optimizations)
14259         flags |= LOOKUP_NONVIRTUAL;
14260
14261       rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
14262
14263       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14264           && ! TYPE_HAS_DESTRUCTOR (type))
14265         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14266                                                build_expr_list (NULL_TREE, build_vbase_delete (type, decl))));
14267
14268       return rval;
14269     }
14270   return 0;
14271 }
14272
14273 /* If DECL is of a type which needs a cleanup, build that cleanup
14274    here.  The cleanup does free the storage with a call to delete.  */
14275
14276 tree
14277 maybe_build_cleanup_and_delete (decl)
14278      tree decl;
14279 {
14280   return maybe_build_cleanup_1 (decl, integer_three_node);
14281 }
14282
14283 /* If DECL is of a type which needs a cleanup, build that cleanup
14284    here.  The cleanup does not free the storage with a call a delete.  */
14285
14286 tree
14287 maybe_build_cleanup (decl)
14288      tree decl;
14289 {
14290   return maybe_build_cleanup_1 (decl, integer_two_node);
14291 }
14292 \f
14293 /* Expand a C++ expression at the statement level.
14294    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14295    The C++ type checker should get all of these out when
14296    expressions are combined with other, type-providing, expressions,
14297    leaving only orphan expressions, such as:
14298
14299    &class::bar;         / / takes its address, but does nothing with it.  */
14300
14301 void
14302 cplus_expand_expr_stmt (exp)
14303      tree exp;
14304 {
14305   if (stmts_are_full_exprs_p)
14306     exp = convert_to_void (exp, "statement");
14307
14308 #if 0
14309   /* We should do this eventually, but right now this causes regex.o from
14310      libg++ to miscompile, and tString to core dump.  */
14311   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14312 #endif
14313
14314   /* If we don't do this, we end up down inside expand_expr
14315      trying to do TYPE_MODE on the ERROR_MARK, and really
14316      go outside the bounds of the type.  */
14317   if (exp != error_mark_node)
14318     expand_expr_stmt (exp);
14319 }
14320
14321 /* When a stmt has been parsed, this function is called.  */
14322
14323 void
14324 finish_stmt ()
14325 {
14326   /* Always assume this statement was not an expression statement.  If
14327      it actually was an expression statement, its our callers
14328      responsibility to fix this up.  */
14329   last_expr_type = NULL_TREE;
14330 }
14331
14332 /* Change a static member function definition into a FUNCTION_TYPE, instead
14333    of the METHOD_TYPE that we create when it's originally parsed.
14334
14335    WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
14336    (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
14337    other decls.  Either pass the addresses of local variables or NULL.  */
14338
14339 void
14340 revert_static_member_fn (decl, fn, argtypes)
14341      tree *decl, *fn, *argtypes;
14342 {
14343   tree tmp;
14344   tree function = fn ? *fn : TREE_TYPE (*decl);
14345   tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
14346
14347   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14348       != TYPE_UNQUALIFIED)
14349     cp_error ("static member function `%#D' declared with type qualifiers",
14350               *decl);
14351
14352   args = TREE_CHAIN (args);
14353   tmp = build_function_type (TREE_TYPE (function), args);
14354   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14355   tmp = build_exception_variant (tmp,
14356                                  TYPE_RAISES_EXCEPTIONS (function));
14357   TREE_TYPE (*decl) = tmp;
14358   if (DECL_ARGUMENTS (*decl))
14359     DECL_ARGUMENTS (*decl) = TREE_CHAIN (DECL_ARGUMENTS (*decl));
14360   DECL_STATIC_FUNCTION_P (*decl) = 1;
14361   if (fn)
14362     *fn = tmp;
14363   if (argtypes)
14364     *argtypes = args;
14365 }
14366
14367 /* Initialize the variables used during compilation of a C++
14368    function.  */
14369
14370 static void
14371 push_cp_function_context (f)
14372      struct function *f;
14373 {
14374   struct language_function *p
14375     = ((struct language_function *)
14376        xcalloc (1, sizeof (struct language_function)));
14377   f->language = p;
14378
14379   /* It takes an explicit call to expand_body to generate RTL for a
14380      function.  */
14381   expanding_p = 0;
14382
14383   /* Whenever we start a new function, we destroy temporaries in the
14384      usual way.  */
14385   stmts_are_full_exprs_p = 1;
14386 }
14387
14388 /* Free the language-specific parts of F, now that we've finished
14389    compiling the function.  */
14390
14391 static void
14392 pop_cp_function_context (f)
14393      struct function *f;
14394 {
14395   if (f->language)
14396     free (f->language);
14397   f->language = 0;
14398 }
14399
14400 /* Mark P for GC.  */
14401
14402 static void
14403 mark_lang_function (p)
14404      struct language_function *p;
14405 {
14406   if (!p)
14407     return;
14408
14409   ggc_mark_tree (p->x_named_labels);
14410   ggc_mark_tree (p->x_ctor_label);
14411   ggc_mark_tree (p->x_dtor_label);
14412   ggc_mark_tree (p->x_base_init_list);
14413   ggc_mark_tree (p->x_member_init_list);
14414   ggc_mark_tree (p->x_current_class_ptr);
14415   ggc_mark_tree (p->x_current_class_ref);
14416   ggc_mark_tree (p->x_eh_spec_try_block);
14417   ggc_mark_tree (p->x_scope_stmt_stack);
14418
14419   ggc_mark_rtx (p->x_result_rtx);
14420
14421   mark_stmt_tree (&p->x_stmt_tree);
14422   mark_binding_level (&p->bindings);
14423 }
14424
14425 /* Mark the language-specific data in F for GC.  */
14426
14427 static void
14428 mark_cp_function_context (f)
14429      struct function *f;
14430 {
14431   mark_lang_function (f->language);
14432 }
14433
14434 int
14435 in_function_p ()
14436 {
14437   return function_depth != 0;
14438 }
14439
14440
14441 void
14442 lang_mark_false_label_stack (l)
14443      struct label_node *l;
14444 {
14445   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14446   my_friendly_assert (l == NULL, 19990904);
14447 }
14448
14449 void
14450 lang_mark_tree (t)
14451      tree t;
14452 {
14453   enum tree_code code = TREE_CODE (t);
14454   if (code == IDENTIFIER_NODE)
14455     {
14456       struct lang_identifier *li = (struct lang_identifier *) t;
14457       struct lang_id2 *li2 = li->x;
14458       ggc_mark_tree (li->namespace_bindings);
14459       ggc_mark_tree (li->bindings);
14460       ggc_mark_tree (li->class_value);
14461       ggc_mark_tree (li->class_template_info);
14462
14463       if (li2)
14464         {
14465           ggc_mark_tree (li2->label_value);
14466           ggc_mark_tree (li2->implicit_decl);
14467           ggc_mark_tree (li2->error_locus);
14468         }
14469     }
14470   else if (code == CPLUS_BINDING)
14471     {
14472       if (BINDING_HAS_LEVEL_P (t))
14473         mark_binding_level (&BINDING_LEVEL (t));
14474       else
14475         ggc_mark_tree (BINDING_SCOPE (t));
14476       ggc_mark_tree (BINDING_VALUE (t));
14477     }
14478   else if (code == OVERLOAD)
14479     ggc_mark_tree (OVL_FUNCTION (t));
14480   else if (code == TEMPLATE_PARM_INDEX)
14481     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14482   else if (TREE_CODE_CLASS (code) == 'd')
14483     {
14484       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14485
14486       if (ld)
14487         {
14488           ggc_mark (ld);
14489           if (!DECL_GLOBAL_CTOR_P (t) && !DECL_GLOBAL_DTOR_P (t))
14490             ggc_mark_tree (ld->decl_flags.u2.access);
14491           ggc_mark_tree (ld->decl_flags.context);
14492           if (TREE_CODE (t) != NAMESPACE_DECL)
14493             ggc_mark_tree (ld->decl_flags.u.template_info);
14494           else
14495             mark_binding_level (&NAMESPACE_LEVEL (t));
14496           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14497             {
14498               ggc_mark_tree (ld->main_decl_variant);
14499               ggc_mark_tree (ld->befriending_classes);
14500               ggc_mark_tree (ld->saved_tree);
14501               if (TREE_CODE (t) == TYPE_DECL)
14502                 ggc_mark_tree (ld->u.sorted_fields);
14503               else if (TREE_CODE (t) == FUNCTION_DECL
14504                        && !DECL_PENDING_INLINE_P (t))
14505                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14506             }
14507         }
14508     }
14509   else if (TREE_CODE_CLASS (code) == 't')
14510     {
14511       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14512
14513       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14514                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14515         {
14516           ggc_mark (lt);
14517           ggc_mark_tree (lt->vfields);
14518           ggc_mark_tree (lt->vbases);
14519           ggc_mark_tree (lt->tags);
14520           ggc_mark_tree (lt->search_slot);
14521           ggc_mark_tree (lt->size);
14522           ggc_mark_tree (lt->pure_virtuals);
14523           ggc_mark_tree (lt->friend_classes);
14524           ggc_mark_tree (lt->rtti);
14525           ggc_mark_tree (lt->methods);
14526           ggc_mark_tree (lt->template_info);
14527           ggc_mark_tree (lt->befriending_classes);
14528         }
14529       else if (lt)
14530         /* In the case of pointer-to-member function types, the
14531            TYPE_LANG_SPECIFIC is really just a tree.  */
14532         ggc_mark_tree ((tree) lt);
14533     }
14534 }
14535