gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "flags.h"
  36 #include "cp-tree.h"
  37 #include "decl.h"
  38 #include "lex.h"
  39 #include <signal.h>
  40 #include "obstack.h"
  41 #include "defaults.h"
  42 #include "output.h"
  43 #include "except.h"
  44 #include "toplev.h"
  45 #include "../hash.h"
  46 #include "defaults.h"
  47 #include "ggc.h"
  48
  49 #define obstack_chunk_alloc xmalloc
  50 #define obstack_chunk_free free
  51
  52 extern struct obstack permanent_obstack;
  53
  54 extern int current_class_depth;
  55
  56 extern tree static_ctors, static_dtors;
  57
  58 extern tree global_namespace;
  59
  60 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  61
  62 /* Use garbage collection.  */
  63
  64 int ggc_p = 1;
  65
  66 #ifndef WCHAR_UNSIGNED
  67 #define WCHAR_UNSIGNED 0
  68 #endif
  69
  70 #ifndef CHAR_TYPE_SIZE
  71 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  72 #endif
  73
  74 #ifndef BOOL_TYPE_SIZE
  75 #ifdef SLOW_BYTE_ACCESS
  76 /* In the new ABI, `bool' has size and alignment `1', on all
  77    platforms.  */
  78 #define BOOL_TYPE_SIZE \
  79   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  80 #else
  81 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  82 #endif
  83 #endif
  84
  85 /* We let tm.h override the types used here, to handle trivial differences
  86    such as the choice of unsigned int or long unsigned int for size_t.
  87    When machines start needing nontrivial differences in the size type,
  88    it would be best to do something here to figure out automatically
  89    from other information what type to use.  */
  90
  91 #ifndef SIZE_TYPE
  92 #define SIZE_TYPE "long unsigned int"
  93 #endif
  94
  95 #ifndef PTRDIFF_TYPE
  96 #define PTRDIFF_TYPE "long int"
  97 #endif
  98
  99 #ifndef WCHAR_TYPE
 100 #define WCHAR_TYPE "int"
 101 #endif
 102
 103 static tree grokparms                           PARAMS ((tree, int));
 104 static const char *redeclaration_error_message  PARAMS ((tree, tree));
 105
 106 static void push_binding_level PARAMS ((struct binding_level *, int,
 107                                       int));
 108 static void pop_binding_level PARAMS ((void));
 109 static void suspend_binding_level PARAMS ((void));
 110 static void resume_binding_level PARAMS ((struct binding_level *));
 111 static struct binding_level *make_binding_level PARAMS ((void));
 112 static void declare_namespace_level PARAMS ((void));
 113 static void signal_catch PARAMS ((int)) ATTRIBUTE_NORETURN;
 114 static void storedecls PARAMS ((tree));
 115 static void require_complete_types_for_parms PARAMS ((tree));
 116 static void push_overloaded_decl_1 PARAMS ((tree));
 117 static int ambi_op_p PARAMS ((tree));
 118 static int unary_op_p PARAMS ((tree));
 119 static tree store_bindings PARAMS ((tree, tree));
 120 static tree lookup_tag_reverse PARAMS ((tree, tree));
 121 static tree obscure_complex_init PARAMS ((tree, tree));
 122 static tree maybe_build_cleanup_1 PARAMS ((tree, tree));
 123 static tree lookup_name_real PARAMS ((tree, int, int, int));
 124 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 125 static void grok_reference_init PARAMS ((tree, tree, tree));
 126 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 127                               enum overload_flags, tree,
 128                               tree, int, int, int, int, int, int, tree));
 129 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 130 static tree lookup_tag PARAMS ((enum tree_code, tree,
 131                               struct binding_level *, int));
 132 static void set_identifier_type_value_with_scope
 133         PARAMS ((tree, tree, struct binding_level *));
 134 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 135 static void record_unknown_type PARAMS ((tree, const char *));
 136 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 137 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 138                                   int));
 139 static void lang_print_error_function PARAMS ((const char *));
 140 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 141 static void check_for_uninitialized_const_var PARAMS ((tree));
 142 static unsigned long typename_hash PARAMS ((hash_table_key));
 143 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 144 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 145 static int add_binding PARAMS ((tree, tree));
 146 static void pop_binding PARAMS ((tree, tree));
 147 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 148 static tree find_binding PARAMS ((tree, tree));
 149 static tree select_decl PARAMS ((tree, int));
 150 static int lookup_flags PARAMS ((int, int));
 151 static tree qualify_lookup PARAMS ((tree, int));
 152 static tree record_builtin_java_type PARAMS ((const char *, int));
 153 static const char *tag_name PARAMS ((enum tag_types code));
 154 static void find_class_binding_level PARAMS ((void));
 155 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 156 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 157 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 158 static int walk_globals_r PARAMS ((tree, void *));
 159 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 160 static tree make_label_decl PARAMS ((tree, int));
 161 static void pop_label PARAMS ((tree));
 162 static void pop_labels PARAMS ((tree));
 163 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 164 static void layout_var_decl PARAMS ((tree));
 165 static void maybe_commonize_var PARAMS ((tree));
 166 static tree check_initializer PARAMS ((tree, tree));
 167 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 168 static void push_cp_function_context PARAMS ((struct function *));
 169 static void pop_cp_function_context PARAMS ((struct function *));
 170 static void mark_binding_level PARAMS ((void *));
 171 static void mark_cp_function_context PARAMS ((struct function *));
 172 static void mark_saved_scope PARAMS ((void *));
 173 static void mark_lang_function PARAMS ((struct language_function *));
 174 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 175 static void save_function_data PARAMS ((tree));
 176 static void check_function_type PARAMS ((tree));
 177 static void destroy_local_var PARAMS ((tree));
 178 static void finish_constructor_body PARAMS ((void));
 179 static void finish_destructor_body PARAMS ((void));
 180 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 181 static tree get_atexit_node PARAMS ((void));
 182 static tree get_dso_handle_node PARAMS ((void));
 183 static tree start_cleanup_fn PARAMS ((void));
 184 static void end_cleanup_fn PARAMS ((void));
 185
 186 #if defined (DEBUG_CP_BINDING_LEVELS)
 187 static void indent PARAMS ((void));
 188 #endif
 189
 190 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 191 tree error_mark_list;
 192
 193 /* The following symbols are subsumed in the cp_global_trees array, and
 194    listed here individually for documentation purposes.
 195
 196    C++ extensions
 197         tree wchar_decl_node;
 198         tree void_zero_node;
 199
 200         tree vtable_entry_type;
 201         tree delta_type_node;
 202 #if 0
 203    Old rtti stuff.
 204         tree __baselist_desc_type_node;
 205         tree __i_desc_type_node, __m_desc_type_node;
 206         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 207 #endif
 208         tree __t_desc_type_node;
 209 #if 0
 210         tree __tp_desc_type_node;
 211 #endif
 212         tree ti_desc_type_node;
 213         tree bltn_desc_type_node, ptr_desc_type_node, ref_desc_type_node;
 214         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 215         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 216         tree ptmd_desc_type_node;
 217         tree base_desc_type_node;
 218 #if 0
 219    Not needed yet?  May be needed one day?
 220         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 221         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 222         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 223 #endif
 224
 225         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 226         tree unknown_type_node;
 227
 228    Array type `vtable_entry_type[]'
 229
 230         tree vtbl_type_node;
 231         tree vtbl_ptr_type_node;
 232
 233    Nnamespace std
 234
 235         tree std_node;
 236
 237    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 238    one that the user will declare, but sufficient to be called
 239    by routines that want to abort the program.
 240
 241         tree abort_fndecl;
 242
 243    The FUNCTION_DECL for the default `::operator delete'.
 244
 245         tree global_delete_fndecl;
 246
 247    Used by RTTI
 248         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 249         tree tinfo_var_id;
 250
 251 */
 252
 253 tree cp_global_trees[CPTI_MAX];
 254
 255 /* Indicates that there is a type value in some namespace, although
 256    that is not necessarily in scope at the moment.  */
 257
 258 static tree global_type_node;
 259
 260 /* Namespace std.  */
 261 int in_std;
 262
 263 /* Expect only namespace names now. */
 264 static int only_namespace_names;
 265
 266 /* If original DECL_RESULT of current function was a register,
 267    but due to being an addressable named return value, would up
 268    on the stack, this variable holds the named return value's
 269    original location.  */
 270
 271 #define original_result_rtx cp_function_chain->x_result_rtx
 272
 273 struct named_label_list
 274 {
 275   struct binding_level *binding_level;
 276   tree names_in_scope;
 277   tree label_decl;
 278   const char *filename_o_goto;
 279   int lineno_o_goto;
 280   struct named_label_list *next;
 281 };
 282
 283 /* Used only for jumps to as-yet undefined labels, since jumps to
 284    defined labels can have their validity checked by stmt.c.  */
 285
 286 #define named_label_uses cp_function_chain->x_named_label_uses
 287
 288 /* A list of objects which have constructors or destructors
 289    which reside in the global scope.  The decl is stored in
 290    the TREE_VALUE slot and the initializer is stored
 291    in the TREE_PURPOSE slot.  */
 292 tree static_aggregates;
 293
 294 /* -- end of C++ */
 295
 296 /* A node for the integer constants 2, and 3.  */
 297
 298 tree integer_two_node, integer_three_node;
 299
 300 /* Parsing a function declarator leaves here a chain of structure
 301    and enum types declared in the parmlist.  */
 302
 303 static tree last_function_parm_tags;
 304
 305 /* Similar, for last_function_parm_tags.  */
 306 tree last_function_parms;
 307 static tree current_function_parm_tags;
 308
 309 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 310    that have names.  Here so we can clear out their names' definitions
 311    at the end of the function.  The TREE_VALUE is a LABEL_DECL; the
 312    TREE_PURPOSE is the previous binding of the label.  */
 313
 314 #define named_labels cp_function_chain->x_named_labels
 315
 316 /* The FUNCTION_DECL for the function currently being compiled,
 317    or 0 if between functions.  */
 318 tree current_function_decl;
 319
 320 /* Set to 0 at beginning of a function definition, and whenever
 321    a label (case or named) is defined.  Set to value of expression
 322    returned from function when that value can be transformed into
 323    a named return value.  */
 324
 325 tree current_function_return_value;
 326
 327 /* Nonzero means use the ISO C99 dialect of C.  */
 328
 329 int flag_isoc99;
 330
 331 /* Nonzero means give `double' the same size as `float'.  */
 332
 333 extern int flag_short_double;
 334
 335 /* Nonzero means don't recognize any builtin functions.  */
 336
 337 extern int flag_no_builtin;
 338
 339 /* Nonzero means don't recognize the non-ANSI builtin functions.
 340    -ansi sets this.  */
 341
 342 extern int flag_no_nonansi_builtin;
 343
 344 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
 345    objects.  */
 346 extern int flag_huge_objects;
 347
 348 /* Nonzero if we want to conserve space in the .o files.  We do this
 349    by putting uninitialized data and runtime initialized data into
 350    .common instead of .data at the expense of not flagging multiple
 351    definitions.  */
 352 extern int flag_conserve_space;
 353 \f
 354 /* C and C++ flags are in decl2.c.  */
 355
 356 /* Flag used when debugging spew.c */
 357
 358 extern int spew_debug;
 359
 360 /* A expression of value 0 with the same precision as a sizetype
 361    node, but signed.  */
 362 tree signed_size_zero_node;
 363
 364 /* The name of the anonymous namespace, throughout this translation
 365    unit.  */
 366 tree anonymous_namespace_name;
 367
 368 \f
 369 /* For each binding contour we allocate a binding_level structure
 370    which records the names defined in that contour.
 371    Contours include:
 372     0) the global one
 373     1) one for each function definition,
 374        where internal declarations of the parameters appear.
 375     2) one for each compound statement,
 376        to record its declarations.
 377
 378    The current meaning of a name can be found by searching the levels
 379    from the current one out to the global one.
 380
 381    Off to the side, may be the class_binding_level.  This exists only
 382    to catch class-local declarations.  It is otherwise nonexistent.
 383
 384    Also there may be binding levels that catch cleanups that must be
 385    run when exceptions occur.  Thus, to see whether a name is bound in
 386    the current scope, it is not enough to look in the
 387    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 388    instead.  */
 389
 390 /* Note that the information in the `names' component of the global contour
 391    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 392
 393 struct binding_level
 394   {
 395     /* A chain of _DECL nodes for all variables, constants, functions,
 396        and typedef types.  These are in the reverse of the order
 397        supplied.  There may be OVERLOADs on this list, too, but they
 398        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 399     tree names;
 400
 401     /* A list of structure, union and enum definitions, for looking up
 402        tag names.
 403        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 404        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 405        or ENUMERAL_TYPE node.
 406
 407        C++: the TREE_VALUE nodes can be simple types for
 408        component_bindings.  */
 409     tree tags;
 410
 411     /* A list of USING_DECL nodes. */
 412     tree usings;
 413
 414     /* A list of used namespaces. PURPOSE is the namespace,
 415        VALUE the common ancestor with this binding_level's namespace. */
 416     tree using_directives;
 417
 418     /* If this binding level is the binding level for a class, then
 419        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 420        is the name of an entity bound in the class; the TREE_VALUE is
 421        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 422        when leaving class scope, we can restore the
 423        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 424        the DECL bound by this name in the class.  */
 425     tree class_shadowed;
 426
 427     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 428        is used for all binding levels.  */
 429     tree type_shadowed;
 430
 431     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 432        label in this scope.  The TREE_PURPOSE is the previous value of
 433        the IDENTIFIER_LABEL VALUE.  */
 434     tree shadowed_labels;
 435
 436     /* For each level (except not the global one),
 437        a chain of BLOCK nodes for all the levels
 438        that were entered and exited one level down.  */
 439     tree blocks;
 440
 441     /* The BLOCK node for this level, if one has been preallocated.
 442        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 443     tree this_block;
 444
 445     /* The _TYPE node for this level, if parm_flag == 2.  */
 446     tree this_class;
 447
 448     /* The binding level which this one is contained in (inherits from).  */
 449     struct binding_level *level_chain;
 450
 451     /* List of decls in `names' that have incomplete
 452        structure or union types.  */
 453     tree incomplete;
 454
 455     /* List of VAR_DECLS saved from a previous for statement.
 456        These would be dead in ISO-conforming code, but might
 457        be referenced in ARM-era code.  These are stored in a
 458        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 459     tree dead_vars_from_for;
 460
 461     /* 1 for the level that holds the parameters of a function.
 462        2 for the level that holds a class declaration.
 463        3 for levels that hold parameter declarations.  */
 464     unsigned parm_flag : 4;
 465
 466     /* 1 means make a BLOCK for this level regardless of all else.
 467        2 for temporary binding contours created by the compiler.  */
 468     unsigned keep : 3;
 469
 470     /* Nonzero if this level "doesn't exist" for tags.  */
 471     unsigned tag_transparent : 1;
 472
 473     /* Nonzero if this level can safely have additional
 474        cleanup-needing variables added to it.  */
 475     unsigned more_cleanups_ok : 1;
 476     unsigned have_cleanups : 1;
 477
 478     /* Nonzero if this level is for storing the decls for template
 479        parameters and generic decls; these decls will be discarded and
 480        replaced with a TEMPLATE_DECL.  */
 481     unsigned pseudo_global : 1;
 482
 483     /* This is set for a namespace binding level.  */
 484     unsigned namespace_p : 1;
 485
 486     /* True if this level is that of a for-statement where we need to
 487        worry about ambiguous (ARM or ISO) scope rules.  */
 488     unsigned is_for_scope : 1;
 489
 490     /* True if this level corresponds to an EH region, as for a try block.  */
 491     unsigned eh_region : 1;
 492
 493     /* One bit left for this word.  */
 494
 495 #if defined(DEBUG_CP_BINDING_LEVELS)
 496     /* Binding depth at which this level began.  */
 497     unsigned binding_depth;
 498 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 499   };
 500
 501 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 502
 503 /* The binding level currently in effect.  */
 504
 505 #define current_binding_level                   \
 506   (cfun                                         \
 507    ? cp_function_chain->bindings                \
 508    : scope_chain->bindings)
 509
 510 /* The binding level of the current class, if any.  */
 511
 512 #define class_binding_level scope_chain->class_bindings
 513
 514 /* A chain of binding_level structures awaiting reuse.  */
 515
 516 static struct binding_level *free_binding_level;
 517
 518 /* The outermost binding level, for names of file scope.
 519    This is created when the compiler is started and exists
 520    through the entire run.  */
 521
 522 static struct binding_level *global_binding_level;
 523
 524 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 525
 526 static int keep_next_level_flag;
 527
 528 #if defined(DEBUG_CP_BINDING_LEVELS)
 529 static int binding_depth = 0;
 530 static int is_class_level = 0;
 531
 532 static void
 533 indent ()
 534 {
 535   register unsigned i;
 536
 537   for (i = 0; i < binding_depth*2; i++)
 538     putc (' ', stderr);
 539 }
 540 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 541
 542 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 543
 544 static void
 545 push_binding_level (newlevel, tag_transparent, keep)
 546      struct binding_level *newlevel;
 547      int tag_transparent, keep;
 548 {
 549   /* Add this level to the front of the chain (stack) of levels that
 550      are active.  */
 551   bzero ((char*) newlevel, sizeof (struct binding_level));
 552   newlevel->level_chain = current_binding_level;
 553   current_binding_level = newlevel;
 554   newlevel->tag_transparent = tag_transparent;
 555   newlevel->more_cleanups_ok = 1;
 556
 557   /* We are called before expand_start_bindings, but after
 558      expand_eh_region_start for a try block; so we check this now,
 559      before the EH block is covered up.  */
 560   newlevel->eh_region = is_eh_region ();
 561
 562   newlevel->keep = keep;
 563 #if defined(DEBUG_CP_BINDING_LEVELS)
 564   newlevel->binding_depth = binding_depth;
 565   indent ();
 566   fprintf (stderr, "push %s level 0x%08x line %d\n",
 567            (is_class_level) ? "class" : "block", newlevel, lineno);
 568   is_class_level = 0;
 569   binding_depth++;
 570 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 571 }
 572
 573 /* Find the innermost enclosing class scope, and reset
 574    CLASS_BINDING_LEVEL appropriately.  */
 575
 576 static void
 577 find_class_binding_level ()
 578 {
 579   struct binding_level *level = current_binding_level;
 580
 581   while (level && level->parm_flag != 2)
 582     level = level->level_chain;
 583   if (level && level->parm_flag == 2)
 584     class_binding_level = level;
 585   else
 586     class_binding_level = 0;
 587 }
 588
 589 static void
 590 pop_binding_level ()
 591 {
 592   if (global_binding_level)
 593     {
 594       /* Cannot pop a level, if there are none left to pop.  */
 595       if (current_binding_level == global_binding_level)
 596         my_friendly_abort (123);
 597     }
 598   /* Pop the current level, and free the structure for reuse.  */
 599 #if defined(DEBUG_CP_BINDING_LEVELS)
 600   binding_depth--;
 601   indent ();
 602   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 603           (is_class_level) ? "class" : "block",
 604           current_binding_level, lineno);
 605   if (is_class_level != (current_binding_level == class_binding_level))
 606     {
 607       indent ();
 608       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 609     }
 610   is_class_level = 0;
 611 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 612   {
 613     register struct binding_level *level = current_binding_level;
 614     current_binding_level = current_binding_level->level_chain;
 615     level->level_chain = free_binding_level;
 616 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 617     if (level->binding_depth != binding_depth)
 618       abort ();
 619 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 620     free_binding_level = level;
 621     find_class_binding_level ();
 622   }
 623 }
 624
 625 static void
 626 suspend_binding_level ()
 627 {
 628   if (class_binding_level)
 629     current_binding_level = class_binding_level;
 630
 631   if (global_binding_level)
 632     {
 633       /* Cannot suspend a level, if there are none left to suspend.  */
 634       if (current_binding_level == global_binding_level)
 635         my_friendly_abort (123);
 636     }
 637   /* Suspend the current level.  */
 638 #if defined(DEBUG_CP_BINDING_LEVELS)
 639   binding_depth--;
 640   indent ();
 641   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 642           (is_class_level) ? "class" : "block",
 643           current_binding_level, lineno);
 644   if (is_class_level != (current_binding_level == class_binding_level))
 645     {
 646       indent ();
 647       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 648     }
 649   is_class_level = 0;
 650 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 651   current_binding_level = current_binding_level->level_chain;
 652   find_class_binding_level ();
 653 }
 654
 655 static void
 656 resume_binding_level (b)
 657      struct binding_level *b;
 658 {
 659   /* Resuming binding levels is meant only for namespaces,
 660      and those cannot nest into classes. */
 661   my_friendly_assert(!class_binding_level, 386);
 662   /* Also, resuming a non-directly nested namespace is a no-no.  */
 663   my_friendly_assert(b->level_chain == current_binding_level, 386);
 664   current_binding_level = b;
 665 #if defined(DEBUG_CP_BINDING_LEVELS)
 666   b->binding_depth = binding_depth;
 667   indent ();
 668   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 669            (is_class_level) ? "class" : "block", b, lineno);
 670   is_class_level = 0;
 671   binding_depth++;
 672 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 673 }
 674 \f
 675 /* Create a new `struct binding_level'.  */
 676
 677 static
 678 struct binding_level *
 679 make_binding_level ()
 680 {
 681   /* NOSTRICT */
 682   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 683 }
 684
 685 /* Nonzero if we are currently in the global binding level.  */
 686
 687 int
 688 global_bindings_p ()
 689 {
 690   return current_binding_level == global_binding_level;
 691 }
 692
 693 /* Return the innermost binding level that is not for a class scope.  */
 694
 695 static struct binding_level *
 696 innermost_nonclass_level ()
 697 {
 698   struct binding_level *b;
 699
 700   b = current_binding_level;
 701   while (b->parm_flag == 2)
 702     b = b->level_chain;
 703
 704   return b;
 705 }
 706
 707 /* Nonzero if we are currently in a toplevel binding level.  This
 708    means either the global binding level or a namespace in a toplevel
 709    binding level.  Since there are no non-toplevel namespace levels,
 710    this really means any namespace or pseudo-global level.  We also
 711    include a class whose context is toplevel.  */
 712
 713 int
 714 toplevel_bindings_p ()
 715 {
 716   struct binding_level *b = innermost_nonclass_level ();
 717
 718   return b->namespace_p || b->pseudo_global;
 719 }
 720
 721 /* Nonzero if this is a namespace scope, or if we are defining a class
 722    which is itself at namespace scope, or whose enclosing class is
 723    such a class, etc.  */
 724
 725 int
 726 namespace_bindings_p ()
 727 {
 728   struct binding_level *b = innermost_nonclass_level ();
 729
 730   return b->namespace_p;
 731 }
 732
 733 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 734    unconditionally.  Otherwise, use the normal logic to decide whether
 735    or not to create a BLOCK.  */
 736
 737 void
 738 keep_next_level (keep)
 739      int keep;
 740 {
 741   keep_next_level_flag = keep;
 742 }
 743
 744 /* Nonzero if the current level needs to have a BLOCK made.  */
 745
 746 int
 747 kept_level_p ()
 748 {
 749   return (current_binding_level->blocks != NULL_TREE
 750           || current_binding_level->keep
 751           || current_binding_level->names != NULL_TREE
 752           || (current_binding_level->tags != NULL_TREE
 753               && !current_binding_level->tag_transparent));
 754 }
 755
 756 void
 757 declare_pseudo_global_level ()
 758 {
 759   current_binding_level->pseudo_global = 1;
 760 }
 761
 762 static void
 763 declare_namespace_level ()
 764 {
 765   current_binding_level->namespace_p = 1;
 766 }
 767
 768 int
 769 pseudo_global_level_p ()
 770 {
 771   return current_binding_level->pseudo_global;
 772 }
 773
 774 void
 775 set_class_shadows (shadows)
 776      tree shadows;
 777 {
 778   class_binding_level->class_shadowed = shadows;
 779 }
 780
 781 /* Enter a new binding level.
 782    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 783    not for that of tags.  */
 784
 785 void
 786 pushlevel (tag_transparent)
 787      int tag_transparent;
 788 {
 789   struct binding_level *newlevel;
 790
 791   if (cfun && !doing_semantic_analysis_p ())
 792     return;
 793
 794   /* Reuse or create a struct for this binding level.  */
 795 #if defined(DEBUG_CP_BINDING_LEVELS)
 796   if (0)
 797 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 798   if (free_binding_level)
 799 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 800     {
 801       newlevel = free_binding_level;
 802       free_binding_level = free_binding_level->level_chain;
 803     }
 804   else
 805     newlevel = make_binding_level ();
 806
 807   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 808   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 809   keep_next_level_flag = 0;
 810 }
 811
 812 void
 813 note_level_for_for ()
 814 {
 815   current_binding_level->is_for_scope = 1;
 816 }
 817
 818 /* For a binding between a name and an entity at a block scope,
 819    this is the `struct binding_level' for the block.  */
 820 #define BINDING_LEVEL(NODE) \
 821    (((struct tree_binding*)NODE)->scope.level)
 822
 823 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 824    level at which this declaration is being bound.  */
 825
 826 static void
 827 push_binding (id, decl, level)
 828      tree id;
 829      tree decl;
 830      struct binding_level* level;
 831 {
 832   tree binding;
 833
 834   binding = make_node (CPLUS_BINDING);
 835
 836   /* Now, fill in the binding information.  */
 837   BINDING_VALUE (binding) = decl;
 838   BINDING_TYPE (binding) = NULL_TREE;
 839   BINDING_LEVEL (binding) = level;
 840   INHERITED_VALUE_BINDING_P (binding) = 0;
 841   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 842   BINDING_HAS_LEVEL_P (binding) = 1;
 843
 844   /* And put it on the front of the list of bindings for ID.  */
 845   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 846   IDENTIFIER_BINDING (id) = binding;
 847 }
 848
 849 /* ID is already bound in the current scope.  But, DECL is an
 850    additional binding for ID in the same scope.  This is the `struct
 851    stat' hack whereby a non-typedef class-name or enum-name can be
 852    bound at the same level as some other kind of entity.  It's the
 853    responsibility of the caller to check that inserting this name is
 854    legal here.  Returns nonzero if the new binding was successful.  */
 855 static int
 856 add_binding (id, decl)
 857      tree id;
 858      tree decl;
 859 {
 860   tree binding = IDENTIFIER_BINDING (id);
 861   int ok = 1;
 862
 863   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 864     /* The new name is the type name.  */
 865     BINDING_TYPE (binding) = decl;
 866   else if (!BINDING_VALUE (binding))
 867     /* This situation arises when push_class_level_binding moves an
 868        inherited type-binding out of the way to make room for a new
 869        value binding.  */
 870     BINDING_VALUE (binding) = decl;
 871   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 872            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 873     {
 874       /* The old binding was a type name.  It was placed in
 875          BINDING_VALUE because it was thought, at the point it was
 876          declared, to be the only entity with such a name.  Move the
 877          type name into the type slot; it is now hidden by the new
 878          binding.  */
 879       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 880       BINDING_VALUE (binding) = decl;
 881       INHERITED_VALUE_BINDING_P (binding) = 0;
 882     }
 883   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 884            && TREE_CODE (decl) == TYPE_DECL
 885            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 886            && same_type_p (TREE_TYPE (decl),
 887                            TREE_TYPE (BINDING_VALUE (binding))))
 888     /* We have two typedef-names, both naming the same type to have
 889        the same name.  This is OK because of:
 890
 891          [dcl.typedef]
 892
 893          In a given scope, a typedef specifier can be used to redefine
 894          the name of any type declared in that scope to refer to the
 895          type to which it already refers.  */
 896     ok = 0;
 897   else
 898     {
 899       cp_error ("declaration of `%#D'", decl);
 900       cp_error_at ("conflicts with previous declaration `%#D'",
 901                    BINDING_VALUE (binding));
 902       ok = 0;
 903     }
 904
 905   return ok;
 906 }
 907
 908 /* Add DECL to the list of things declared in B.  */
 909
 910 static void
 911 add_decl_to_level (decl, b)
 912      tree decl;
 913      struct binding_level *b;
 914 {
 915   /* We build up the list in reverse order, and reverse it later if
 916      necessary.  */
 917   TREE_CHAIN (decl) = b->names;
 918   b->names = decl;
 919 }
 920
 921 /* Bind DECL to ID in the current_binding_level, assumed to be a local
 922    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
 923    doesn't really belong to this binding level, that it got here
 924    through a using-declaration.  */
 925
 926 void
 927 push_local_binding (id, decl, flags)
 928      tree id;
 929      tree decl;
 930      int flags;
 931 {
 932   struct binding_level *b;
 933
 934   /* Skip over any local classes.  This makes sense if we call
 935      push_local_binding with a friend decl of a local class.  */
 936   b = current_binding_level;
 937   while (b->parm_flag == 2)
 938     b = b->level_chain;
 939
 940   if (lookup_name_current_level (id))
 941     {
 942       /* Supplement the existing binding.  */
 943       if (!add_binding (id, decl))
 944         /* It didn't work.  Something else must be bound at this
 945            level.  Do not add DECL to the list of things to pop
 946            later.  */
 947         return;
 948     }
 949   else
 950     /* Create a new binding.  */
 951     push_binding (id, decl, b);
 952
 953   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
 954     /* We must put the OVERLOAD into a TREE_LIST since the
 955        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
 956        decls that got here through a using-declaration.  */
 957     decl = build_tree_list (NULL_TREE, decl);
 958
 959   /* And put DECL on the list of things declared by the current
 960      binding level.  */
 961   add_decl_to_level (decl, b);
 962 }
 963
 964 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
 965    binding was successful.  */
 966
 967 int
 968 push_class_binding (id, decl)
 969      tree id;
 970      tree decl;
 971 {
 972   int result = 1;
 973   tree binding = IDENTIFIER_BINDING (id);
 974   tree context;
 975
 976   /* Note that we declared this value so that we can issue an error if
 977      this an illegal redeclaration of a name already used for some
 978      other purpose.  */
 979   note_name_declared_in_class (id, decl);
 980
 981   if (binding && BINDING_LEVEL (binding) == class_binding_level)
 982     /* Supplement the existing binding.  */
 983     result = add_binding (id, decl);
 984   else
 985     /* Create a new binding.  */
 986     push_binding (id, decl, class_binding_level);
 987
 988   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
 989      class-level declaration.  Note that we do not use DECL here
 990      because of the possibility of the `struct stat' hack; if DECL is
 991      a class-name or enum-name we might prefer a field-name, or some
 992      such.  */
 993   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
 994
 995   /* If this is a binding from a base class, mark it as such.  */
 996   binding = IDENTIFIER_BINDING (id);
 997   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
 998     {
 999       /* Any implicit typename must be from a base-class.  The
1000          context for an implicit typename declaration is always
1001          the derived class in which the lookup was done, so the checks
1002          based on the context of DECL below will not trigger.  */
1003       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1004         INHERITED_VALUE_BINDING_P (binding) = 1;
1005       else
1006         {
1007           if (TREE_CODE (decl) == OVERLOAD)
1008             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1009           else
1010             {
1011               my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd',
1012                                   0);
1013               context = CP_DECL_CONTEXT (decl);
1014             }
1015
1016           if (is_properly_derived_from (current_class_type, context))
1017             INHERITED_VALUE_BINDING_P (binding) = 1;
1018           else
1019             INHERITED_VALUE_BINDING_P (binding) = 0;
1020         }
1021     }
1022   else if (BINDING_VALUE (binding) == decl)
1023     /* We only encounter a TREE_LIST when push_class_decls detects an
1024        ambiguity.  Such an ambiguity can be overridden by a definition
1025        in this class.  */
1026     INHERITED_VALUE_BINDING_P (binding) = 1;
1027
1028   return result;
1029 }
1030
1031 /* Remove the binding for DECL which should be the innermost binding
1032    for ID.  */
1033
1034 static void
1035 pop_binding (id, decl)
1036      tree id;
1037      tree decl;
1038 {
1039   tree binding;
1040
1041   if (id == NULL_TREE)
1042     /* It's easiest to write the loops that call this function without
1043        checking whether or not the entities involved have names.  We
1044        get here for such an entity.  */
1045     return;
1046
1047   /* Get the innermost binding for ID.  */
1048   binding = IDENTIFIER_BINDING (id);
1049
1050   /* The name should be bound.  */
1051   my_friendly_assert (binding != NULL_TREE, 0);
1052
1053   /* The DECL will be either the ordinary binding or the type
1054      binding for this identifier.  Remove that binding.  */
1055   if (BINDING_VALUE (binding) == decl)
1056     BINDING_VALUE (binding) = NULL_TREE;
1057   else if (BINDING_TYPE (binding) == decl)
1058     BINDING_TYPE (binding) = NULL_TREE;
1059   else
1060     my_friendly_abort (0);
1061
1062   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1063     /* We're completely done with the innermost binding for this
1064        identifier.  Unhook it from the list of bindings.  */
1065     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1066 }
1067
1068 /* When a label goes out of scope, check to see if that label was used
1069    in a valid manner, and issue any appropriate warnings or errors.  */
1070
1071 static void
1072 pop_label (link)
1073      tree link;
1074 {
1075   tree label = TREE_VALUE (link);
1076
1077   if (!processing_template_decl && doing_semantic_analysis_p ())
1078     {
1079       if (DECL_INITIAL (label) == NULL_TREE)
1080         {
1081           cp_error_at ("label `%D' used but not defined", label);
1082           /* Avoid crashing later.  */
1083           define_label (input_filename, 1, DECL_NAME (label));
1084         }
1085       else if (warn_unused && !TREE_USED (label))
1086         cp_warning_at ("label `%D' defined but not used", label);
1087     }
1088
1089   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), TREE_PURPOSE (link));
1090 }
1091
1092 /* At the end of a function, all labels declared within the fucntion
1093    go out of scope.  BLOCK is the top-level block for the
1094    function.  */
1095
1096 static void
1097 pop_labels (block)
1098      tree block;
1099 {
1100   tree link;
1101
1102   /* Clear out the definitions of all label names, since their scopes
1103      end here.  */
1104   for (link = named_labels; link; link = TREE_CHAIN (link))
1105     {
1106       pop_label (link);
1107       /* Put the labels into the "variables" of the top-level block,
1108          so debugger can see them.  */
1109       TREE_CHAIN (TREE_VALUE (link)) = BLOCK_VARS (block);
1110       BLOCK_VARS (block) = TREE_VALUE (link);
1111     }
1112
1113   named_labels = NULL_TREE;
1114 }
1115
1116 /* Exit a binding level.
1117    Pop the level off, and restore the state of the identifier-decl mappings
1118    that were in effect when this level was entered.
1119
1120    If KEEP == 1, this level had explicit declarations, so
1121    and create a "block" (a BLOCK node) for the level
1122    to record its declarations and subblocks for symbol table output.
1123
1124    If FUNCTIONBODY is nonzero, this level is the body of a function,
1125    so create a block as if KEEP were set and also clear out all
1126    label names.
1127
1128    If REVERSE is nonzero, reverse the order of decls before putting
1129    them into the BLOCK.  */
1130
1131 tree
1132 poplevel (keep, reverse, functionbody)
1133      int keep;
1134      int reverse;
1135      int functionbody;
1136 {
1137   register tree link;
1138   /* The chain of decls was accumulated in reverse order.
1139      Put it into forward order, just for cleanliness.  */
1140   tree decls;
1141   int tmp = functionbody;
1142   int real_functionbody;
1143   tree tags;
1144   tree subblocks;
1145   tree block = NULL_TREE;
1146   tree decl;
1147   int block_previously_created;
1148   int leaving_for_scope;
1149
1150   if (cfun && !doing_semantic_analysis_p ())
1151     return NULL_TREE;
1152
1153   my_friendly_assert (current_binding_level->parm_flag != 2,
1154                       19990916);
1155
1156   real_functionbody = (current_binding_level->keep == 2
1157                        ? ((functionbody = 0), tmp) : functionbody);
1158   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1159   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1160
1161   my_friendly_assert (!current_binding_level->class_shadowed,
1162                       19990414);
1163
1164   /* We used to use KEEP == 2 to indicate that the new block should go
1165      at the beginning of the list of blocks at this binding level,
1166      rather than the end.  This hack is no longer used.  */
1167   my_friendly_assert (keep == 0 || keep == 1, 0);
1168
1169   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1170                       (HOST_WIDE_INT) current_binding_level->level_chain,
1171                       current_binding_level->parm_flag,
1172                       current_binding_level->keep);
1173
1174   if (current_binding_level->keep == 1)
1175     keep = 1;
1176
1177   /* Get the decls in the order they were written.
1178      Usually current_binding_level->names is in reverse order.
1179      But parameter decls were previously put in forward order.  */
1180
1181   if (reverse)
1182     current_binding_level->names
1183       = decls = nreverse (current_binding_level->names);
1184   else
1185     decls = current_binding_level->names;
1186
1187   /* Output any nested inline functions within this block
1188      if they weren't already output.  */
1189   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1190     if (TREE_CODE (decl) == FUNCTION_DECL
1191         && ! TREE_ASM_WRITTEN (decl)
1192         && DECL_INITIAL (decl) != NULL_TREE
1193         && TREE_ADDRESSABLE (decl)
1194         && decl_function_context (decl) == current_function_decl)
1195       {
1196         /* If this decl was copied from a file-scope decl
1197            on account of a block-scope extern decl,
1198            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1199         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1200           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1201         else
1202           {
1203             push_function_context ();
1204             output_inline_function (decl);
1205             pop_function_context ();
1206           }
1207       }
1208
1209   /* When not in function-at-a-time mode, expand_end_bindings will
1210      warn about unused variables.  But, in function-at-a-time mode
1211      expand_end_bindings is not passed the list of variables in the
1212      current scope, and therefore no warning is emitted.  So, we
1213      explicitly warn here.  */
1214   if (!processing_template_decl)
1215     warn_about_unused_variables (getdecls ());
1216
1217   /* If there were any declarations or structure tags in that level,
1218      or if this level is a function body,
1219      create a BLOCK to record them for the life of this function.  */
1220   block = NULL_TREE;
1221   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1222   if (block_previously_created)
1223     block = current_binding_level->this_block;
1224   else if (keep == 1 || functionbody)
1225     block = make_node (BLOCK);
1226   if (block != NULL_TREE)
1227     {
1228       if (block_previously_created)
1229         {
1230           if (decls || tags || subblocks)
1231             {
1232               if (BLOCK_VARS (block))
1233                 warning ("internal compiler error: debugging info corrupted");
1234
1235               BLOCK_VARS (block) = decls;
1236
1237               /* We can have previous subblocks and new subblocks when
1238                  doing fixup_gotos with complex cleanups.  We chain the new
1239                  subblocks onto the end of any pre-existing subblocks.  */
1240               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1241                                                  subblocks);
1242             }
1243         }
1244       else
1245         {
1246           BLOCK_VARS (block) = decls;
1247           BLOCK_SUBBLOCKS (block) = subblocks;
1248         }
1249     }
1250
1251   /* In each subblock, record that this is its superior.  */
1252   if (keep >= 0)
1253     for (link = subblocks; link; link = TREE_CHAIN (link))
1254       BLOCK_SUPERCONTEXT (link) = block;
1255
1256   /* We still support the old for-scope rules, whereby the variables
1257      in a for-init statement were in scope after the for-statement
1258      ended.  We only use the new rules in flag_new_for_scope is
1259      nonzero.  */
1260   leaving_for_scope
1261     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1262
1263   /* Remove declarations for all the DECLs in this level.  */
1264   for (link = decls; link; link = TREE_CHAIN (link))
1265     {
1266       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1267         {
1268           tree outer_binding
1269             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1270           tree ns_binding;
1271
1272           if (!outer_binding)
1273             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1274           else
1275             ns_binding = NULL_TREE;
1276
1277           if (outer_binding
1278               && (BINDING_LEVEL (outer_binding)
1279                   == current_binding_level->level_chain))
1280             /* We have something like:
1281
1282                  int i;
1283                  for (int i; ;);
1284
1285                and we are leaving the `for' scope.  There's no reason to
1286                keep the binding of the inner `i' in this case.  */
1287             pop_binding (DECL_NAME (link), link);
1288           else if ((outer_binding
1289                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1290                         == TYPE_DECL))
1291                    || (ns_binding
1292                        && TREE_CODE (ns_binding) == TYPE_DECL))
1293             /* Here, we have something like:
1294
1295                  typedef int I;
1296
1297                  void f () {
1298                    for (int I; ;);
1299                  }
1300
1301                We must pop the for-scope binding so we know what's a
1302                type and what isn't.  */
1303             pop_binding (DECL_NAME (link), link);
1304           else
1305             {
1306               /* Mark this VAR_DECL as dead so that we can tell we left it
1307                  there only for backward compatibility.  */
1308               DECL_DEAD_FOR_LOCAL (link) = 1;
1309
1310               /* Keep track of what should of have happenned when we
1311                  popped the binding.  */
1312               if (outer_binding && BINDING_VALUE (outer_binding))
1313                 DECL_SHADOWED_FOR_VAR (link)
1314                   = BINDING_VALUE (outer_binding);
1315
1316               /* Add it to the list of dead variables in the next
1317                  outermost binding to that we can remove these when we
1318                  leave that binding.  */
1319               current_binding_level->level_chain->dead_vars_from_for
1320                 = tree_cons (NULL_TREE, link,
1321                              current_binding_level->level_chain->
1322                              dead_vars_from_for);
1323
1324               /* Although we don't pop the CPLUS_BINDING, we do clear
1325                  its BINDING_LEVEL since the level is going away now.  */
1326               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1327                 = 0;
1328             }
1329         }
1330       else
1331         {
1332           /* Remove the binding.  */
1333           decl = link;
1334           if (TREE_CODE (decl) == TREE_LIST)
1335             decl = TREE_VALUE (decl);
1336           if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
1337             pop_binding (DECL_NAME (decl), decl);
1338           else if (TREE_CODE (decl) == OVERLOAD)
1339             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1340           else
1341             my_friendly_abort (0);
1342         }
1343     }
1344
1345   /* Remove declarations for any `for' variables from inner scopes
1346      that we kept around.  */
1347   for (link = current_binding_level->dead_vars_from_for;
1348        link; link = TREE_CHAIN (link))
1349     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1350
1351   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1352   for (link = current_binding_level->type_shadowed;
1353        link; link = TREE_CHAIN (link))
1354     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1355
1356   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1357   for (link = current_binding_level->shadowed_labels;
1358        link;
1359        link = TREE_CHAIN (link))
1360     pop_label (link);
1361
1362   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1363      list if a `using' declaration put them there.  The debugging
1364      back-ends won't understand OVERLOAD, so we remove them here.
1365      Because the BLOCK_VARS are (temporarily) shared with
1366      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1367      popped all the bindings.  */
1368   if (block)
1369     {
1370       tree* d;
1371
1372       for (d = &BLOCK_VARS (block); *d; )
1373         {
1374           if (TREE_CODE (*d) == TREE_LIST)
1375             *d = TREE_CHAIN (*d);
1376           else
1377             d = &TREE_CHAIN (*d);
1378         }
1379     }
1380
1381   /* If the level being exited is the top level of a function,
1382      check over all the labels.  */
1383   if (functionbody)
1384     {
1385       /* Since this is the top level block of a function, the vars are
1386          the function's parameters.  Don't leave them in the BLOCK
1387          because they are found in the FUNCTION_DECL instead.  */
1388       BLOCK_VARS (block) = 0;
1389       pop_labels (block);
1390     }
1391
1392   /* Any uses of undefined labels now operate under constraints
1393      of next binding contour.  */
1394   if (cfun)
1395     {
1396       struct binding_level *level_chain;
1397       level_chain = current_binding_level->level_chain;
1398       if (level_chain)
1399         {
1400           struct named_label_list *labels;
1401           for (labels = named_label_uses; labels; labels = labels->next)
1402             if (labels->binding_level == current_binding_level)
1403               {
1404                 labels->binding_level = level_chain;
1405                 labels->names_in_scope = level_chain->names;
1406               }
1407         }
1408     }
1409
1410   tmp = current_binding_level->keep;
1411
1412   pop_binding_level ();
1413   if (functionbody)
1414     DECL_INITIAL (current_function_decl) = block;
1415   else if (block)
1416     {
1417       if (!block_previously_created)
1418         current_binding_level->blocks
1419           = chainon (current_binding_level->blocks, block);
1420     }
1421   /* If we did not make a block for the level just exited,
1422      any blocks made for inner levels
1423      (since they cannot be recorded as subblocks in that level)
1424      must be carried forward so they will later become subblocks
1425      of something else.  */
1426   else if (subblocks)
1427     current_binding_level->blocks
1428       = chainon (current_binding_level->blocks, subblocks);
1429
1430   /* Each and every BLOCK node created here in `poplevel' is important
1431      (e.g. for proper debugging information) so if we created one
1432      earlier, mark it as "used".  */
1433   if (block)
1434     TREE_USED (block) = 1;
1435
1436   /* Take care of compiler's internal binding structures.  */
1437   if (tmp == 2)
1438     {
1439       tree scope_stmts;
1440
1441       scope_stmts
1442         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1443       if (block)
1444         {
1445           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1446           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1447         }
1448
1449       block = poplevel (keep, reverse, functionbody);
1450     }
1451
1452   return block;
1453 }
1454
1455 /* Delete the node BLOCK from the current binding level.
1456    This is used for the block inside a stmt expr ({...})
1457    so that the block can be reinserted where appropriate.  */
1458
1459 void
1460 delete_block (block)
1461      tree block;
1462 {
1463   tree t;
1464   if (current_binding_level->blocks == block)
1465     current_binding_level->blocks = TREE_CHAIN (block);
1466   for (t = current_binding_level->blocks; t;)
1467     {
1468       if (TREE_CHAIN (t) == block)
1469         TREE_CHAIN (t) = TREE_CHAIN (block);
1470       else
1471         t = TREE_CHAIN (t);
1472     }
1473   TREE_CHAIN (block) = NULL_TREE;
1474   /* Clear TREE_USED which is always set by poplevel.
1475      The flag is set again if insert_block is called.  */
1476   TREE_USED (block) = 0;
1477 }
1478
1479 /* Insert BLOCK at the end of the list of subblocks of the
1480    current binding level.  This is used when a BIND_EXPR is expanded,
1481    to handle the BLOCK node inside the BIND_EXPR.  */
1482
1483 void
1484 insert_block (block)
1485      tree block;
1486 {
1487   TREE_USED (block) = 1;
1488   current_binding_level->blocks
1489     = chainon (current_binding_level->blocks, block);
1490 }
1491
1492 /* Set the BLOCK node for the innermost scope
1493    (the one we are currently in).  */
1494
1495 void
1496 set_block (block)
1497     register tree block;
1498 {
1499   current_binding_level->this_block = block;
1500 }
1501
1502 /* Do a pushlevel for class declarations.  */
1503
1504 void
1505 pushlevel_class ()
1506 {
1507   register struct binding_level *newlevel;
1508
1509   /* Reuse or create a struct for this binding level.  */
1510 #if defined(DEBUG_CP_BINDING_LEVELS)
1511   if (0)
1512 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1513   if (free_binding_level)
1514 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1515     {
1516       newlevel = free_binding_level;
1517       free_binding_level = free_binding_level->level_chain;
1518     }
1519   else
1520     newlevel = make_binding_level ();
1521
1522 #if defined(DEBUG_CP_BINDING_LEVELS)
1523   is_class_level = 1;
1524 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1525
1526   push_binding_level (newlevel, 0, 0);
1527
1528   class_binding_level = current_binding_level;
1529   class_binding_level->parm_flag = 2;
1530   class_binding_level->this_class = current_class_type;
1531 }
1532
1533 /* ...and a poplevel for class declarations.  */
1534
1535 void
1536 poplevel_class ()
1537 {
1538   register struct binding_level *level = class_binding_level;
1539   tree shadowed;
1540
1541   my_friendly_assert (level != 0, 354);
1542
1543   /* If we're leaving a toplevel class, don't bother to do the setting
1544      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1545      shouldn't even be used when current_class_type isn't set, and second,
1546      if we don't touch it here, we're able to use the cache effect if the
1547      next time we're entering a class scope, it is the same class.  */
1548   if (current_class_depth != 1)
1549     {
1550       struct binding_level* b;
1551
1552       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1553       for (shadowed = level->class_shadowed;
1554            shadowed;
1555            shadowed = TREE_CHAIN (shadowed))
1556         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1557
1558       /* Find the next enclosing class, and recreate
1559          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1560       b = level->level_chain;
1561       while (b && b->parm_flag != 2)
1562         b = b->level_chain;
1563
1564       if (b)
1565         for (shadowed = b->class_shadowed;
1566              shadowed;
1567              shadowed = TREE_CHAIN (shadowed))
1568           {
1569             tree t;
1570
1571             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1572             while (t && BINDING_LEVEL (t) != b)
1573               t = TREE_CHAIN (t);
1574
1575             if (t)
1576               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1577                 = BINDING_VALUE (t);
1578           }
1579     }
1580   else
1581     /* Remember to save what IDENTIFIER's were bound in this scope so we
1582        can recover from cache misses.  */
1583     {
1584       previous_class_type = current_class_type;
1585       previous_class_values = class_binding_level->class_shadowed;
1586     }
1587   for (shadowed = level->type_shadowed;
1588        shadowed;
1589        shadowed = TREE_CHAIN (shadowed))
1590     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1591
1592   /* Remove the bindings for all of the class-level declarations.  */
1593   for (shadowed = level->class_shadowed;
1594        shadowed;
1595        shadowed = TREE_CHAIN (shadowed))
1596     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1597
1598   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1599                       (HOST_WIDE_INT) class_binding_level->level_chain,
1600                       class_binding_level->parm_flag,
1601                       class_binding_level->keep);
1602
1603   /* Now, pop out of the binding level which we created up in the
1604      `pushlevel_class' routine.  */
1605 #if defined(DEBUG_CP_BINDING_LEVELS)
1606   is_class_level = 1;
1607 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1608
1609   pop_binding_level ();
1610 }
1611
1612 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1613    for any names in enclosing classes.  */
1614
1615 void
1616 clear_identifier_class_values ()
1617 {
1618   tree t;
1619
1620   if (!class_binding_level)
1621     return;
1622
1623   for (t = class_binding_level->class_shadowed;
1624        t;
1625        t = TREE_CHAIN (t))
1626     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1627 }
1628
1629 /* Returns non-zero if T is a virtual function table.  */
1630
1631 int
1632 vtable_decl_p (t, data)
1633      tree t;
1634      void *data ATTRIBUTE_UNUSED;
1635 {
1636   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1637 }
1638
1639 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1640    functions.  */
1641
1642 int
1643 vtype_decl_p (t, data)
1644      tree t;
1645      void *data ATTRIBUTE_UNUSED;
1646 {
1647   return (TREE_CODE (t) == TYPE_DECL
1648           && TREE_TYPE (t) != error_mark_node
1649           && TYPE_LANG_SPECIFIC (TREE_TYPE (t))
1650           && CLASSTYPE_VSIZE (TREE_TYPE (t)));
1651 }
1652
1653 /* Return the declarations that are members of the namespace NS.  */
1654
1655 tree
1656 cp_namespace_decls (ns)
1657      tree ns;
1658 {
1659   return NAMESPACE_LEVEL (ns)->names;
1660 }
1661
1662 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1663    itself, calling F for each.  The DATA is passed to F as well.  */
1664
1665 static int
1666 walk_namespaces_r (namespace, f, data)
1667      tree namespace;
1668      walk_namespaces_fn f;
1669      void *data;
1670 {
1671   tree current;
1672   int result = 0;
1673
1674   result |= (*f) (namespace, data);
1675
1676   for (current = cp_namespace_decls (namespace);
1677        current;
1678        current = TREE_CHAIN (current))
1679     {
1680       if (TREE_CODE (current) != NAMESPACE_DECL
1681           || DECL_NAMESPACE_ALIAS (current))
1682         continue;
1683       if (!DECL_LANG_SPECIFIC (current))
1684         {
1685           /* Hmm. std. */
1686           my_friendly_assert (current == std_node, 393);
1687           continue;
1688         }
1689
1690       /* We found a namespace.  */
1691       result |= walk_namespaces_r (current, f, data);
1692     }
1693
1694   return result;
1695 }
1696
1697 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1698    F as well.  */
1699
1700 int
1701 walk_namespaces (f, data)
1702      walk_namespaces_fn f;
1703      void *data;
1704 {
1705   return walk_namespaces_r (global_namespace, f, data);
1706 }
1707
1708 struct walk_globals_data {
1709   walk_globals_pred p;
1710   walk_globals_fn f;
1711   void *data;
1712 };
1713
1714 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1715    for which P returns non-zero, call F with its address.  If any call
1716    to F returns a non-zero value, return a non-zero value.  */
1717
1718 static int
1719 walk_globals_r (namespace, data)
1720      tree namespace;
1721      void *data;
1722 {
1723   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1724   walk_globals_pred p = wgd->p;
1725   walk_globals_fn f = wgd->f;
1726   void *d = wgd->data;
1727   tree *t;
1728   int result = 0;
1729
1730   t = &NAMESPACE_LEVEL (namespace)->names;
1731
1732   while (*t)
1733     {
1734       tree glbl = *t;
1735
1736       if ((*p) (glbl, d))
1737         result |= (*f) (t, d);
1738
1739       /* If F changed *T, then *T still points at the next item to
1740          examine.  */
1741       if (*t == glbl)
1742         t = &TREE_CHAIN (*t);
1743     }
1744
1745   return result;
1746 }
1747
1748 /* Walk the global declarations.  Whenever one is found for which P
1749    returns non-zero, call F with its address.  If any call to F
1750    returns a non-zero value, return a non-zero value.  */
1751
1752 int
1753 walk_globals (p, f, data)
1754      walk_globals_pred p;
1755      walk_globals_fn f;
1756      void *data;
1757 {
1758   struct walk_globals_data wgd;
1759   wgd.p = p;
1760   wgd.f = f;
1761   wgd.data = data;
1762
1763   return walk_namespaces (walk_globals_r, &wgd);
1764 }
1765
1766 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1767    DATA is non-NULL, this is the last time we will call
1768    wrapup_global_declarations for this NAMESPACE.  */
1769
1770 int
1771 wrapup_globals_for_namespace (namespace, data)
1772      tree namespace;
1773      void *data;
1774 {
1775   tree globals = cp_namespace_decls (namespace);
1776   int len = list_length (globals);
1777   tree *vec = (tree *) alloca (sizeof (tree) * len);
1778   int i;
1779   int result;
1780   tree decl;
1781   int last_time = (data != 0);
1782
1783   if (last_time && namespace == global_namespace)
1784     /* Let compile_file handle the global namespace.  */
1785     return 0;
1786
1787   /* Process the decls in reverse order--earliest first.
1788      Put them into VEC from back to front, then take out from front.  */
1789
1790   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1791     vec[len - i - 1] = decl;
1792
1793   if (last_time)
1794     {
1795       check_global_declarations (vec, len);
1796       return 0;
1797     }
1798
1799   /* Temporarily mark vtables as external.  That prevents
1800      wrapup_global_declarations from writing them out; we must process
1801      them ourselves in finish_vtable_vardecl.  */
1802   for (i = 0; i < len; ++i)
1803     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1804       {
1805         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1806         DECL_EXTERNAL (vec[i]) = 1;
1807       }
1808
1809   /* Write out any globals that need to be output.  */
1810   result = wrapup_global_declarations (vec, len);
1811
1812   /* Undo the hack to DECL_EXTERNAL above.  */
1813   for (i = 0; i < len; ++i)
1814     if (vtable_decl_p (vec[i], /*data=*/0)
1815         && DECL_NOT_REALLY_EXTERN (vec[i]))
1816       {
1817         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1818         DECL_EXTERNAL (vec[i]) = 0;
1819       }
1820
1821   return result;
1822 }
1823
1824 \f
1825 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1826
1827 static void
1828 mark_binding_level (arg)
1829      void *arg;
1830 {
1831   struct binding_level *lvl = *(struct binding_level **)arg;
1832
1833   while (lvl)
1834     {
1835       ggc_mark_tree (lvl->names);
1836       ggc_mark_tree (lvl->tags);
1837       ggc_mark_tree (lvl->usings);
1838       ggc_mark_tree (lvl->using_directives);
1839       ggc_mark_tree (lvl->class_shadowed);
1840       ggc_mark_tree (lvl->type_shadowed);
1841       ggc_mark_tree (lvl->shadowed_labels);
1842       ggc_mark_tree (lvl->blocks);
1843       ggc_mark_tree (lvl->this_block);
1844       ggc_mark_tree (lvl->this_class);
1845       ggc_mark_tree (lvl->incomplete);
1846       ggc_mark_tree (lvl->dead_vars_from_for);
1847
1848       lvl = lvl->level_chain;
1849     }
1850 }
1851 \f
1852 /* For debugging.  */
1853 static int no_print_functions = 0;
1854 static int no_print_builtins = 0;
1855
1856 void
1857 print_binding_level (lvl)
1858      struct binding_level *lvl;
1859 {
1860   tree t;
1861   int i = 0, len;
1862   fprintf (stderr, " blocks=");
1863   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1864   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1865            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1866   if (lvl->tag_transparent)
1867     fprintf (stderr, " tag-transparent");
1868   if (lvl->more_cleanups_ok)
1869     fprintf (stderr, " more-cleanups-ok");
1870   if (lvl->have_cleanups)
1871     fprintf (stderr, " have-cleanups");
1872   fprintf (stderr, "\n");
1873   if (lvl->names)
1874     {
1875       fprintf (stderr, " names:\t");
1876       /* We can probably fit 3 names to a line?  */
1877       for (t = lvl->names; t; t = TREE_CHAIN (t))
1878         {
1879           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1880             continue;
1881           if (no_print_builtins
1882               && (TREE_CODE (t) == TYPE_DECL)
1883               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1884             continue;
1885
1886           /* Function decls tend to have longer names.  */
1887           if (TREE_CODE (t) == FUNCTION_DECL)
1888             len = 3;
1889           else
1890             len = 2;
1891           i += len;
1892           if (i > 6)
1893             {
1894               fprintf (stderr, "\n\t");
1895               i = len;
1896             }
1897           print_node_brief (stderr, "", t, 0);
1898           if (t == error_mark_node)
1899             break;
1900         }
1901       if (i)
1902         fprintf (stderr, "\n");
1903     }
1904   if (lvl->tags)
1905     {
1906       fprintf (stderr, " tags:\t");
1907       i = 0;
1908       for (t = lvl->tags; t; t = TREE_CHAIN (t))
1909         {
1910           if (TREE_PURPOSE (t) == NULL_TREE)
1911             len = 3;
1912           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1913             len = 2;
1914           else
1915             len = 4;
1916           i += len;
1917           if (i > 5)
1918             {
1919               fprintf (stderr, "\n\t");
1920               i = len;
1921             }
1922           if (TREE_PURPOSE (t) == NULL_TREE)
1923             {
1924               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1925               fprintf (stderr, ">");
1926             }
1927           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1928             print_node_brief (stderr, "", TREE_VALUE (t), 0);
1929           else
1930             {
1931               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1932               print_node_brief (stderr, "", TREE_VALUE (t), 0);
1933               fprintf (stderr, ">");
1934             }
1935         }
1936       if (i)
1937         fprintf (stderr, "\n");
1938     }
1939   if (lvl->class_shadowed)
1940     {
1941       fprintf (stderr, " class-shadowed:");
1942       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1943         {
1944           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1945         }
1946       fprintf (stderr, "\n");
1947     }
1948   if (lvl->type_shadowed)
1949     {
1950       fprintf (stderr, " type-shadowed:");
1951       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1952         {
1953           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1954         }
1955       fprintf (stderr, "\n");
1956     }
1957 }
1958
1959 void
1960 print_other_binding_stack (stack)
1961      struct binding_level *stack;
1962 {
1963   struct binding_level *level;
1964   for (level = stack; level != global_binding_level; level = level->level_chain)
1965     {
1966       fprintf (stderr, "binding level ");
1967       fprintf (stderr, HOST_PTR_PRINTF, level);
1968       fprintf (stderr, "\n");
1969       print_binding_level (level);
1970     }
1971 }
1972
1973 void
1974 print_binding_stack ()
1975 {
1976   struct binding_level *b;
1977   fprintf (stderr, "current_binding_level=");
1978   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1979   fprintf (stderr, "\nclass_binding_level=");
1980   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1981   fprintf (stderr, "\nglobal_binding_level=");
1982   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1983   fprintf (stderr, "\n");
1984   if (class_binding_level)
1985     {
1986       for (b = class_binding_level; b; b = b->level_chain)
1987         if (b == current_binding_level)
1988           break;
1989       if (b)
1990         b = class_binding_level;
1991       else
1992         b = current_binding_level;
1993     }
1994   else
1995     b = current_binding_level;
1996   print_other_binding_stack (b);
1997   fprintf (stderr, "global:\n");
1998   print_binding_level (global_binding_level);
1999 }
2000
2001 /* Namespace binding access routines: The namespace_bindings field of
2002    the identifier is polymorphic, with three possible values:
2003    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2004    indicating the BINDING_VALUE of global_namespace. */
2005
2006 /* Check whether the a binding for the name to scope is known.
2007    Assumes that the bindings of the name are already a list
2008    of bindings. Returns the binding found, or NULL_TREE. */
2009
2010 static tree
2011 find_binding (name, scope)
2012      tree name;
2013      tree scope;
2014 {
2015   tree iter, prev = NULL_TREE;
2016
2017   scope = ORIGINAL_NAMESPACE (scope);
2018
2019   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2020        iter = TREE_CHAIN (iter))
2021     {
2022       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2023       if (BINDING_SCOPE (iter) == scope)
2024         {
2025           /* Move binding found to the front of the list, so
2026              subsequent lookups will find it faster. */
2027           if (prev)
2028             {
2029               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2030               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2031               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2032             }
2033           return iter;
2034         }
2035       prev = iter;
2036     }
2037   return NULL_TREE;
2038 }
2039
2040 /* Always returns a binding for name in scope. If the
2041    namespace_bindings is not a list, convert it to one first.
2042    If no binding is found, make a new one. */
2043
2044 tree
2045 binding_for_name (name, scope)
2046      tree name;
2047      tree scope;
2048 {
2049   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2050   tree result;
2051
2052   scope = ORIGINAL_NAMESPACE (scope);
2053
2054   if (b && TREE_CODE (b) != CPLUS_BINDING)
2055     {
2056       /* Get rid of optimization for global scope. */
2057       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2058       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2059       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2060     }
2061   if (b && (result = find_binding (name, scope)))
2062     return result;
2063   /* Not found, make a new one. */
2064   result = make_node (CPLUS_BINDING);
2065   TREE_CHAIN (result) = b;
2066   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2067   BINDING_SCOPE (result) = scope;
2068   BINDING_TYPE (result) = NULL_TREE;
2069   BINDING_VALUE (result) = NULL_TREE;
2070   return result;
2071 }
2072
2073 /* Return the binding value for name in scope, considering that
2074    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2075
2076 tree
2077 namespace_binding (name, scope)
2078      tree name;
2079      tree scope;
2080 {
2081   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2082   if (b == NULL_TREE)
2083     return NULL_TREE;
2084   if (scope == NULL_TREE)
2085     scope = global_namespace;
2086   if (TREE_CODE (b) != CPLUS_BINDING)
2087     return (scope == global_namespace) ? b : NULL_TREE;
2088   name = find_binding (name,scope);
2089   if (name == NULL_TREE)
2090     return name;
2091   return BINDING_VALUE (name);
2092 }
2093
2094 /* Set the binding value for name in scope. If modifying the binding
2095    of global_namespace is attempted, try to optimize it. */
2096
2097 void
2098 set_namespace_binding (name, scope, val)
2099      tree name;
2100      tree scope;
2101      tree val;
2102 {
2103   tree b;
2104
2105   if (scope == NULL_TREE)
2106     scope = global_namespace;
2107
2108   if (scope == global_namespace)
2109     {
2110       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2111       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2112         {
2113           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2114           return;
2115         }
2116     }
2117   b = binding_for_name (name, scope);
2118   BINDING_VALUE (b) = val;
2119 }
2120
2121 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2122    select a name that is unique to this compilation unit.  */
2123
2124 void
2125 push_namespace (name)
2126      tree name;
2127 {
2128   tree d = NULL_TREE;
2129   int need_new = 1;
2130   int implicit_use = 0;
2131   int global = 0;
2132   if (!global_namespace)
2133     {
2134       /* This must be ::. */
2135       my_friendly_assert (name == get_identifier ("::"), 377);
2136       global = 1;
2137     }
2138   else if (!name)
2139     {
2140       /* The name of anonymous namespace is unique for the translation
2141          unit.  */
2142       if (!anonymous_namespace_name)
2143         anonymous_namespace_name = get_file_function_name ('N');
2144       name = anonymous_namespace_name;
2145       d = IDENTIFIER_NAMESPACE_VALUE (name);
2146       if (d)
2147         /* Reopening anonymous namespace.  */
2148         need_new = 0;
2149       implicit_use = 1;
2150     }
2151   else if (current_namespace == global_namespace
2152            && name == DECL_NAME (std_node))
2153     {
2154       in_std++;
2155       return;
2156     }
2157   else
2158     {
2159       /* Check whether this is an extended namespace definition. */
2160       d = IDENTIFIER_NAMESPACE_VALUE (name);
2161       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2162         {
2163           need_new = 0;
2164           if (DECL_NAMESPACE_ALIAS (d))
2165             {
2166               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2167                         d, DECL_NAMESPACE_ALIAS (d));
2168               d = DECL_NAMESPACE_ALIAS (d);
2169             }
2170         }
2171     }
2172
2173   if (need_new)
2174     {
2175       /* Make a new namespace, binding the name to it. */
2176       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2177       /* The global namespace is not pushed, and the global binding
2178          level is set elsewhere.  */
2179       if (!global)
2180         {
2181           d = pushdecl (d);
2182           pushlevel (0);
2183           declare_namespace_level ();
2184           NAMESPACE_LEVEL (d) = current_binding_level;
2185         }
2186     }
2187   else
2188     resume_binding_level (NAMESPACE_LEVEL (d));
2189
2190   if (implicit_use)
2191     do_using_directive (d);
2192   /* Enter the name space. */
2193   current_namespace = d;
2194 }
2195
2196 /* Pop from the scope of the current namespace.  */
2197
2198 void
2199 pop_namespace ()
2200 {
2201   if (current_namespace == global_namespace)
2202     {
2203       my_friendly_assert (in_std>0, 980421);
2204       in_std--;
2205       return;
2206     }
2207   current_namespace = CP_DECL_CONTEXT (current_namespace);
2208   /* The binding level is not popped, as it might be re-opened later.  */
2209   suspend_binding_level ();
2210 }
2211
2212 /* Push into the scope of the namespace NS, even if it is deeply
2213    nested within another namespace.  */
2214
2215 void
2216 push_nested_namespace (ns)
2217      tree ns;
2218 {
2219   if (ns == global_namespace)
2220     push_to_top_level ();
2221   else
2222     {
2223       push_nested_namespace (CP_DECL_CONTEXT (ns));
2224       push_namespace (DECL_NAME (ns));
2225     }
2226 }
2227
2228 /* Pop back from the scope of the namespace NS, which was previously
2229    entered with push_nested_namespace.  */
2230
2231 void
2232 pop_nested_namespace (ns)
2233      tree ns;
2234 {
2235   while (ns != global_namespace)
2236     {
2237       pop_namespace ();
2238       ns = CP_DECL_CONTEXT (ns);
2239     }
2240
2241   pop_from_top_level ();
2242 }
2243
2244 \f
2245 /* Subroutines for reverting temporarily to top-level for instantiation
2246    of templates and such.  We actually need to clear out the class- and
2247    local-value slots of all identifiers, so that only the global values
2248    are at all visible.  Simply setting current_binding_level to the global
2249    scope isn't enough, because more binding levels may be pushed.  */
2250 struct saved_scope *scope_chain;
2251
2252 /* Mark ST for GC.  */
2253
2254 static void
2255 mark_stmt_tree (st)
2256      struct stmt_tree *st;
2257 {
2258   ggc_mark_tree (st->x_last_stmt);
2259   ggc_mark_tree (st->x_last_expr_type);
2260 }
2261
2262 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2263
2264 static void
2265 mark_saved_scope (arg)
2266      void *arg;
2267 {
2268   struct saved_scope *t = *(struct saved_scope **)arg;
2269   while (t)
2270     {
2271       mark_binding_level (&t->class_bindings);
2272       ggc_mark_tree (t->old_bindings);
2273       ggc_mark_tree (t->old_namespace);
2274       ggc_mark_tree (t->class_name);
2275       ggc_mark_tree (t->class_type);
2276       ggc_mark_tree (t->access_specifier);
2277       ggc_mark_tree (t->function_decl);
2278       if (t->lang_base)
2279         ggc_mark_tree_varray (t->lang_base);
2280       ggc_mark_tree (t->lang_name);
2281       ggc_mark_tree (t->x_function_parms);
2282       ggc_mark_tree (t->template_parms);
2283       ggc_mark_tree (t->x_previous_class_type);
2284       ggc_mark_tree (t->x_previous_class_values);
2285       ggc_mark_tree (t->x_saved_tree);
2286       ggc_mark_tree (t->incomplete);
2287       ggc_mark_tree (t->lookups);
2288
2289       mark_stmt_tree (&t->x_stmt_tree);
2290       mark_binding_level (&t->bindings);
2291       t = t->prev;
2292     }
2293 }
2294
2295 static tree
2296 store_bindings (names, old_bindings)
2297      tree names, old_bindings;
2298 {
2299   tree t;
2300   for (t = names; t; t = TREE_CHAIN (t))
2301     {
2302       tree binding, t1, id;
2303
2304       if (TREE_CODE (t) == TREE_LIST)
2305         id = TREE_PURPOSE (t);
2306       else
2307         id = DECL_NAME (t);
2308
2309       if (!id
2310           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2311              we have no IDENTIFIER_BINDING if we have left the class
2312              scope, but cached the class-level declarations.  */
2313           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2314         continue;
2315
2316       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2317         if (TREE_VEC_ELT (t1, 0) == id)
2318           goto skip_it;
2319
2320       binding = make_tree_vec (4);
2321
2322       if (id)
2323         {
2324           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2325           TREE_VEC_ELT (binding, 0) = id;
2326           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2327           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2328           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2329           IDENTIFIER_BINDING (id) = NULL_TREE;
2330           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2331         }
2332       TREE_CHAIN (binding) = old_bindings;
2333       old_bindings = binding;
2334     skip_it:
2335       ;
2336     }
2337   return old_bindings;
2338 }
2339
2340 void
2341 maybe_push_to_top_level (pseudo)
2342      int pseudo;
2343 {
2344   struct saved_scope *s;
2345   struct binding_level *b;
2346   tree old_bindings;
2347   int need_pop;
2348
2349   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2350
2351   b = scope_chain ? current_binding_level : 0;
2352
2353   /* If we're in the middle of some function, save our state.  */
2354   if (cfun)
2355     {
2356       need_pop = 1;
2357       push_function_context_to (NULL_TREE);
2358     }
2359   else
2360     need_pop = 0;
2361
2362   old_bindings = NULL_TREE;
2363   if (scope_chain && previous_class_type)
2364     old_bindings = store_bindings (previous_class_values, old_bindings);
2365
2366   /* Have to include global_binding_level, because class-level decls
2367      aren't listed anywhere useful.  */
2368   for (; b; b = b->level_chain)
2369     {
2370       tree t;
2371
2372       /* Template IDs are inserted into the global level. If they were
2373          inserted into namespace level, finish_file wouldn't find them
2374          when doing pending instantiations. Therefore, don't stop at
2375          namespace level, but continue until :: .  */
2376       if (b == global_binding_level || (pseudo && b->pseudo_global))
2377         break;
2378
2379       old_bindings = store_bindings (b->names, old_bindings);
2380       /* We also need to check class_shadowed to save class-level type
2381          bindings, since pushclass doesn't fill in b->names.  */
2382       if (b->parm_flag == 2)
2383         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2384
2385       /* Unwind type-value slots back to top level.  */
2386       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2387         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2388     }
2389   s->prev = scope_chain;
2390   s->old_bindings = old_bindings;
2391   s->bindings = b;
2392   s->need_pop_function_context = need_pop;
2393   s->function_decl = current_function_decl;
2394
2395   scope_chain = s;
2396   current_function_decl = NULL_TREE;
2397   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2398   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2399   current_lang_name = lang_name_cplusplus;
2400   strict_prototype = strict_prototypes_lang_cplusplus;
2401   current_namespace = global_namespace;
2402 }
2403
2404 void
2405 push_to_top_level ()
2406 {
2407   maybe_push_to_top_level (0);
2408 }
2409
2410 void
2411 pop_from_top_level ()
2412 {
2413   struct saved_scope *s = scope_chain;
2414   tree t;
2415
2416   /* Clear out class-level bindings cache.  */
2417   if (previous_class_type)
2418     invalidate_class_lookup_cache ();
2419
2420   VARRAY_FREE (current_lang_base);
2421
2422   scope_chain = s->prev;
2423   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2424     {
2425       tree id = TREE_VEC_ELT (t, 0);
2426       if (id)
2427         {
2428           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2429           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2430           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2431         }
2432     }
2433
2434   if (current_lang_name == lang_name_cplusplus)
2435     strict_prototype = strict_prototypes_lang_cplusplus;
2436   else if (current_lang_name == lang_name_c)
2437     strict_prototype = strict_prototypes_lang_c;
2438
2439   /* If we were in the middle of compiling a function, restore our
2440      state.  */
2441   if (s->need_pop_function_context)
2442     pop_function_context_from (NULL_TREE);
2443   current_function_decl = s->function_decl;
2444
2445   free (s);
2446 }
2447 \f
2448 /* Push a definition of struct, union or enum tag "name".
2449    into binding_level "b".   "type" should be the type node,
2450    We assume that the tag "name" is not already defined.
2451
2452    Note that the definition may really be just a forward reference.
2453    In that case, the TYPE_SIZE will be a NULL_TREE.
2454
2455    C++ gratuitously puts all these tags in the name space.  */
2456
2457 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2458    record the shadowed value for this binding contour.  TYPE is
2459    the type that ID maps to.  */
2460
2461 static void
2462 set_identifier_type_value_with_scope (id, type, b)
2463      tree id;
2464      tree type;
2465      struct binding_level *b;
2466 {
2467   if (!b->namespace_p)
2468     {
2469       /* Shadow the marker, not the real thing, so that the marker
2470          gets restored later. */
2471       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2472       b->type_shadowed
2473         = tree_cons (id, old_type_value, b->type_shadowed);
2474     }
2475   else
2476     {
2477       tree binding = binding_for_name (id, current_namespace);
2478       BINDING_TYPE (binding) = type;
2479       /* Store marker instead of real type. */
2480       type = global_type_node;
2481     }
2482   SET_IDENTIFIER_TYPE_VALUE (id, type);
2483 }
2484
2485 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2486
2487 void
2488 set_identifier_type_value (id, type)
2489      tree id;
2490      tree type;
2491 {
2492   set_identifier_type_value_with_scope (id, type, current_binding_level);
2493 }
2494
2495 /* Return the type associated with id. */
2496
2497 tree
2498 identifier_type_value (id)
2499      tree id;
2500 {
2501   /* There is no type with that name, anywhere. */
2502   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2503     return NULL_TREE;
2504   /* This is not the type marker, but the real thing. */
2505   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2506     return REAL_IDENTIFIER_TYPE_VALUE (id);
2507   /* Have to search for it. It must be on the global level, now.
2508      Ask lookup_name not to return non-types. */
2509   id = lookup_name_real (id, 2, 1, 0);
2510   if (id)
2511     return TREE_TYPE (id);
2512   return NULL_TREE;
2513 }
2514
2515 /* Pop off extraneous binding levels left over due to syntax errors.
2516
2517    We don't pop past namespaces, as they might be valid.  */
2518
2519 void
2520 pop_everything ()
2521 {
2522 #ifdef DEBUG_CP_BINDING_LEVELS
2523   fprintf (stderr, "XXX entering pop_everything ()\n");
2524 #endif
2525   while (!toplevel_bindings_p ())
2526     {
2527       if (current_binding_level->parm_flag == 2)
2528         pop_nested_class ();
2529       else
2530         poplevel (0, 0, 0);
2531     }
2532 #ifdef DEBUG_CP_BINDING_LEVELS
2533   fprintf (stderr, "XXX leaving pop_everything ()\n");
2534 #endif
2535 }
2536
2537 /* The type TYPE is being declared.  If it is a class template, or a
2538    specialization of a class template, do any processing required and
2539    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2540    being declared a friend.  B is the binding level at which this TYPE
2541    should be bound.
2542
2543    Returns the TYPE_DECL for TYPE, which may have been altered by this
2544    processing.  */
2545
2546 static tree
2547 maybe_process_template_type_declaration (type, globalize, b)
2548      tree type;
2549      int globalize;
2550      struct binding_level* b;
2551 {
2552   tree decl = TYPE_NAME (type);
2553
2554   if (processing_template_parmlist)
2555     /* You can't declare a new template type in a template parameter
2556        list.  But, you can declare a non-template type:
2557
2558          template <class A*> struct S;
2559
2560        is a forward-declaration of `A'.  */
2561     ;
2562   else
2563     {
2564       maybe_check_template_type (type);
2565
2566       my_friendly_assert (IS_AGGR_TYPE (type)
2567                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2568
2569
2570       if (processing_template_decl)
2571         {
2572           /* This may change after the call to
2573              push_template_decl_real, but we want the original value.  */
2574           tree name = DECL_NAME (decl);
2575
2576           decl = push_template_decl_real (decl, globalize);
2577           /* If the current binding level is the binding level for the
2578              template parameters (see the comment in
2579              begin_template_parm_list) and the enclosing level is a class
2580              scope, and we're not looking at a friend, push the
2581              declaration of the member class into the class scope.  In the
2582              friend case, push_template_decl will already have put the
2583              friend into global scope, if appropriate.  */
2584           if (TREE_CODE (type) != ENUMERAL_TYPE
2585               && !globalize && b->pseudo_global
2586               && b->level_chain->parm_flag == 2)
2587             {
2588               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2589               /* Put this tag on the list of tags for the class, since
2590                  that won't happen below because B is not the class
2591                  binding level, but is instead the pseudo-global level.  */
2592               b->level_chain->tags =
2593                 tree_cons (name, type, b->level_chain->tags);
2594               if (TYPE_SIZE (current_class_type) == NULL_TREE)
2595                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2596             }
2597         }
2598     }
2599
2600   return decl;
2601 }
2602
2603 /* In C++, you don't have to write `struct S' to refer to `S'; you
2604    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2605    if the user had written `typedef struct S S'.  Create and return
2606    the TYPE_DECL for TYPE.  */
2607
2608 tree
2609 create_implicit_typedef (name, type)
2610      tree name;
2611      tree type;
2612 {
2613   tree decl;
2614
2615   decl = build_decl (TYPE_DECL, name, type);
2616   SET_DECL_ARTIFICIAL (decl);
2617   /* There are other implicit type declarations, like the one *within*
2618      a class that allows you to write `S::S'.  We must distinguish
2619      amongst these.  */
2620   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2621   TYPE_NAME (type) = decl;
2622
2623   return decl;
2624 }
2625
2626 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2627    Normally put it into the inner-most non-tag-transparent scope,
2628    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2629    The latter is needed for implicit declarations.  */
2630
2631 void
2632 pushtag (name, type, globalize)
2633      tree name, type;
2634      int globalize;
2635 {
2636   register struct binding_level *b;
2637
2638   b = current_binding_level;
2639   while (b->tag_transparent
2640          || (globalize && b->parm_flag == 2))
2641     b = b->level_chain;
2642
2643   b->tags = tree_cons (name, type, b->tags);
2644
2645   if (name)
2646     {
2647       /* Do C++ gratuitous typedefing.  */
2648       if (IDENTIFIER_TYPE_VALUE (name) != type)
2649         {
2650           register tree d = NULL_TREE;
2651           int in_class = 0;
2652           tree context = TYPE_CONTEXT (type);
2653
2654           if (! context)
2655             {
2656               tree cs = current_scope ();
2657
2658               if (! globalize)
2659                 context = cs;
2660               else if (cs != NULL_TREE
2661                        && TREE_CODE_CLASS (TREE_CODE (cs)) == 't')
2662                 /* When declaring a friend class of a local class, we want
2663                    to inject the newly named class into the scope
2664                    containing the local class, not the namespace scope.  */
2665                 context = decl_function_context (get_type_decl (cs));
2666             }
2667           if (!context)
2668             context = current_namespace;
2669
2670           if ((b->pseudo_global && b->level_chain->parm_flag == 2)
2671               || b->parm_flag == 2)
2672             in_class = 1;
2673
2674           if (current_lang_name == lang_name_java)
2675             TYPE_FOR_JAVA (type) = 1;
2676
2677           d = create_implicit_typedef (name, type);
2678           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2679           if (! in_class)
2680             set_identifier_type_value_with_scope (name, type, b);
2681
2682           d = maybe_process_template_type_declaration (type,
2683                                                        globalize, b);
2684
2685           if (b->parm_flag == 2)
2686             {
2687               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2688                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2689                    class.  But if it's a member template class, we
2690                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2691                    is done later.  */
2692                 finish_member_declaration (d);
2693               else
2694                 pushdecl_class_level (d);
2695             }
2696           else
2697             d = pushdecl_with_scope (d, b);
2698
2699           if (ANON_AGGRNAME_P (name))
2700             DECL_IGNORED_P (d) = 1;
2701
2702           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2703           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2704           if (!uses_template_parms (type))
2705             DECL_ASSEMBLER_NAME (d)
2706               = get_identifier (build_overload_name (type, 1, 1));
2707         }
2708       if (b->parm_flag == 2)
2709         {
2710           if (TYPE_SIZE (current_class_type) == NULL_TREE)
2711             CLASSTYPE_TAGS (current_class_type) = b->tags;
2712         }
2713     }
2714
2715   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2716     /* Use the canonical TYPE_DECL for this node.  */
2717     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2718   else
2719     {
2720       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2721          will be the tagged type we just added to the current
2722          binding level.  This fake NULL-named TYPE_DECL node helps
2723          dwarfout.c to know when it needs to output a
2724          representation of a tagged type, and it also gives us a
2725          convenient place to record the "scope start" address for
2726          the tagged type.  */
2727
2728       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2729       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2730     }
2731 }
2732
2733 /* Counter used to create anonymous type names.  */
2734
2735 static int anon_cnt = 0;
2736
2737 /* Return an IDENTIFIER which can be used as a name for
2738    anonymous structs and unions.  */
2739
2740 tree
2741 make_anon_name ()
2742 {
2743   char buf[32];
2744
2745   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2746   return get_identifier (buf);
2747 }
2748
2749 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2750    This keeps dbxout from getting confused.  */
2751
2752 void
2753 clear_anon_tags ()
2754 {
2755   register struct binding_level *b;
2756   register tree tags;
2757   static int last_cnt = 0;
2758
2759   /* Fast out if no new anon names were declared.  */
2760   if (last_cnt == anon_cnt)
2761     return;
2762
2763   b = current_binding_level;
2764   while (b->tag_transparent)
2765     b = b->level_chain;
2766   tags = b->tags;
2767   while (tags)
2768     {
2769       /* A NULL purpose means we have already processed all tags
2770          from here to the end of the list.  */
2771       if (TREE_PURPOSE (tags) == NULL_TREE)
2772         break;
2773       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2774         TREE_PURPOSE (tags) = NULL_TREE;
2775       tags = TREE_CHAIN (tags);
2776     }
2777   last_cnt = anon_cnt;
2778 }
2779 \f
2780 /* Subroutine of duplicate_decls: return truthvalue of whether
2781    or not types of these decls match.
2782
2783    For C++, we must compare the parameter list so that `int' can match
2784    `int&' in a parameter position, but `int&' is not confused with
2785    `const int&'.  */
2786
2787 int
2788 decls_match (newdecl, olddecl)
2789      tree newdecl, olddecl;
2790 {
2791   int types_match;
2792
2793   if (newdecl == olddecl)
2794     return 1;
2795
2796   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2797     /* If the two DECLs are not even the same kind of thing, we're not
2798        interested in their types.  */
2799     return 0;
2800
2801   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2802     {
2803       tree f1 = TREE_TYPE (newdecl);
2804       tree f2 = TREE_TYPE (olddecl);
2805       tree p1 = TYPE_ARG_TYPES (f1);
2806       tree p2 = TYPE_ARG_TYPES (f2);
2807
2808       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2809           && ! (DECL_LANGUAGE (newdecl) == lang_c
2810                 && DECL_LANGUAGE (olddecl) == lang_c))
2811         return 0;
2812
2813       if (TREE_CODE (f1) != TREE_CODE (f2))
2814         return 0;
2815
2816       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2817         {
2818           if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2819               && p2 == NULL_TREE)
2820             {
2821               types_match = self_promoting_args_p (p1);
2822               if (p1 == void_list_node)
2823                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2824             }
2825           else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2826                    && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2827             {
2828               types_match = self_promoting_args_p (p2);
2829               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2830             }
2831           else
2832             types_match = compparms (p1, p2);
2833         }
2834       else
2835         types_match = 0;
2836     }
2837   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2838     {
2839       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2840                                 DECL_TEMPLATE_PARMS (olddecl)))
2841         return 0;
2842
2843       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2844         types_match = 1;
2845       else
2846         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2847                                    DECL_TEMPLATE_RESULT (newdecl));
2848     }
2849   else
2850     {
2851       if (TREE_TYPE (newdecl) == error_mark_node)
2852         types_match = TREE_TYPE (olddecl) == error_mark_node;
2853       else if (TREE_TYPE (olddecl) == NULL_TREE)
2854         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2855       else if (TREE_TYPE (newdecl) == NULL_TREE)
2856         types_match = 0;
2857       else
2858         types_match = comptypes (TREE_TYPE (newdecl),
2859                                  TREE_TYPE (olddecl),
2860                                  COMPARE_REDECLARATION);
2861     }
2862
2863   return types_match;
2864 }
2865
2866 /* If NEWDECL is `static' and an `extern' was seen previously,
2867    warn about it.  OLDDECL is the previous declaration.
2868
2869    Note that this does not apply to the C++ case of declaring
2870    a variable `extern const' and then later `const'.
2871
2872    Don't complain about built-in functions, since they are beyond
2873    the user's control.  */
2874
2875 static void
2876 warn_extern_redeclared_static (newdecl, olddecl)
2877      tree newdecl, olddecl;
2878 {
2879   static const char *explicit_extern_static_warning
2880     = "`%D' was declared `extern' and later `static'";
2881   static const char *implicit_extern_static_warning
2882     = "`%D' was declared implicitly `extern' and later `static'";
2883
2884   tree name;
2885
2886   if (TREE_CODE (newdecl) == TYPE_DECL
2887       || TREE_CODE (newdecl) == TEMPLATE_DECL)
2888     return;
2889
2890   /* Don't get confused by static member functions; that's a different
2891      use of `static'.  */
2892   if (TREE_CODE (newdecl) == FUNCTION_DECL
2893       && DECL_STATIC_FUNCTION_P (newdecl))
2894     return;
2895
2896   /* If the old declaration was `static', or the new one isn't, then
2897      then everything is OK.  */
2898   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2899     return;
2900
2901   /* It's OK to declare a builtin function as `static'.  */
2902   if (TREE_CODE (olddecl) == FUNCTION_DECL
2903       && DECL_ARTIFICIAL (olddecl))
2904     return;
2905
2906   name = DECL_ASSEMBLER_NAME (newdecl);
2907   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2908               ? implicit_extern_static_warning
2909               : explicit_extern_static_warning, newdecl);
2910   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2911 }
2912
2913 /* Handle when a new declaration NEWDECL has the same name as an old
2914    one OLDDECL in the same binding contour.  Prints an error message
2915    if appropriate.
2916
2917    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2918    Otherwise, return 0.  */
2919
2920 int
2921 duplicate_decls (newdecl, olddecl)
2922      tree newdecl, olddecl;
2923 {
2924   unsigned olddecl_uid = DECL_UID (olddecl);
2925   int olddecl_friend = 0, types_match = 0;
2926   int new_defines_function = 0;
2927
2928   if (newdecl == olddecl)
2929     return 1;
2930
2931   types_match = decls_match (newdecl, olddecl);
2932
2933   /* If either the type of the new decl or the type of the old decl is an
2934      error_mark_node, then that implies that we have already issued an
2935      error (earlier) for some bogus type specification, and in that case,
2936      it is rather pointless to harass the user with yet more error message
2937      about the same declaration, so just pretend the types match here.  */
2938   if (TREE_TYPE (newdecl) == error_mark_node
2939       || TREE_TYPE (olddecl) == error_mark_node)
2940     types_match = 1;
2941
2942   /* Check for redeclaration and other discrepancies. */
2943   if (TREE_CODE (olddecl) == FUNCTION_DECL
2944       && DECL_ARTIFICIAL (olddecl))
2945     {
2946       if (TREE_CODE (newdecl) != FUNCTION_DECL)
2947         {
2948           /* If you declare a built-in or predefined function name as static,
2949              the old definition is overridden, but optionally warn this was a
2950              bad choice of name.  */
2951           if (! TREE_PUBLIC (newdecl))
2952             {
2953               if (warn_shadow)
2954                 cp_warning ("shadowing %s function `%#D'",
2955                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2956                             olddecl);
2957               /* Discard the old built-in function.  */
2958               return 0;
2959             }
2960           /* If the built-in is not ansi, then programs can override
2961              it even globally without an error.  */
2962           else if (! DECL_BUILT_IN (olddecl))
2963             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2964                         olddecl, newdecl);
2965           else
2966             {
2967               cp_error ("declaration of `%#D'", newdecl);
2968               cp_error ("conflicts with built-in declaration `%#D'",
2969                         olddecl);
2970             }
2971           return 0;
2972         }
2973       else if (!types_match)
2974         {
2975           if ((DECL_LANGUAGE (newdecl) == lang_c
2976                && DECL_LANGUAGE (olddecl) == lang_c)
2977               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
2978                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
2979             {
2980               /* A near match; override the builtin.  */
2981
2982               if (TREE_PUBLIC (newdecl))
2983                 {
2984                   cp_warning ("new declaration `%#D'", newdecl);
2985                   cp_warning ("ambiguates built-in declaration `%#D'",
2986                               olddecl);
2987                 }
2988               else if (warn_shadow)
2989                 cp_warning ("shadowing %s function `%#D'",
2990                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2991                             olddecl);
2992             }
2993           else
2994             /* Discard the old built-in function.  */
2995             return 0;
2996         }
2997
2998       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
2999         {
3000           /* If a builtin function is redeclared as `static', merge
3001              the declarations, but make the original one static.  */
3002           DECL_THIS_STATIC (olddecl) = 1;
3003           TREE_PUBLIC (olddecl) = 0;
3004
3005           /* Make the olddeclaration consistent with the new one so that
3006              all remnants of the builtin-ness of this function will be
3007              banished.  */
3008           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3009           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3010           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3011           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3012                                        newdecl);
3013         }
3014     }
3015   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3016     {
3017       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3018            && TREE_CODE (newdecl) != TYPE_DECL
3019            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3020                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3021           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3022               && TREE_CODE (olddecl) != TYPE_DECL
3023               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3024                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3025                         == TYPE_DECL))))
3026         {
3027           /* We do nothing special here, because C++ does such nasty
3028              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3029              get shadowed, and know that if we need to find a TYPE_DECL
3030              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3031              slot of the identifier.  */
3032           return 0;
3033         }
3034
3035       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3036            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3037           || (TREE_CODE (olddecl) == FUNCTION_DECL
3038               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3039         return 0;
3040
3041       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3042       if (TREE_CODE (olddecl) == TREE_LIST)
3043         olddecl = TREE_VALUE (olddecl);
3044       cp_error_at ("previous declaration of `%#D'", olddecl);
3045
3046       /* New decl is completely inconsistent with the old one =>
3047          tell caller to replace the old one.  */
3048
3049       return 0;
3050     }
3051   else if (!types_match)
3052     {
3053       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3054         /* These are certainly not duplicate declarations; they're
3055            from different scopes.  */
3056         return 0;
3057
3058       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3059         {
3060           /* The name of a class template may not be declared to refer to
3061              any other template, class, function, object, namespace, value,
3062              or type in the same scope.  */
3063           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3064               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3065             {
3066               cp_error ("declaration of template `%#D'", newdecl);
3067               cp_error_at ("conflicts with previous declaration `%#D'",
3068                            olddecl);
3069             }
3070           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3071                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3072                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3073                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3074                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3075                                            DECL_TEMPLATE_PARMS (olddecl)))
3076             {
3077               cp_error ("new declaration `%#D'", newdecl);
3078               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3079             }
3080           return 0;
3081         }
3082       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3083         {
3084           if (DECL_LANGUAGE (newdecl) == lang_c
3085               && DECL_LANGUAGE (olddecl) == lang_c)
3086             {
3087               cp_error ("declaration of C function `%#D' conflicts with",
3088                         newdecl);
3089               cp_error_at ("previous declaration `%#D' here", olddecl);
3090             }
3091           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3092                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3093             {
3094               cp_error ("new declaration `%#D'", newdecl);
3095               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3096             }
3097           else
3098             return 0;
3099         }
3100
3101       /* Already complained about this, so don't do so again.  */
3102       else if (current_class_type == NULL_TREE
3103           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3104         {
3105           cp_error ("conflicting types for `%#D'", newdecl);
3106           cp_error_at ("previous declaration as `%#D'", olddecl);
3107         }
3108     }
3109   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3110             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3111                  && (!DECL_TEMPLATE_INFO (newdecl)
3112                      || (DECL_TI_TEMPLATE (newdecl)
3113                          != DECL_TI_TEMPLATE (olddecl))))
3114                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3115                     && (!DECL_TEMPLATE_INFO (olddecl)
3116                         || (DECL_TI_TEMPLATE (olddecl)
3117                             != DECL_TI_TEMPLATE (newdecl))))))
3118     /* It's OK to have a template specialization and a non-template
3119        with the same type, or to have specializations of two
3120        different templates with the same type.  Note that if one is a
3121        specialization, and the other is an instantiation of the same
3122        template, that we do not exit at this point.  That situation
3123        can occur if we instantiate a template class, and then
3124        specialize one of its methods.  This situation is legal, but
3125        the declarations must be merged in the usual way.  */
3126     return 0;
3127   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3128            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3129                 && !DECL_USE_TEMPLATE (newdecl))
3130                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3131                    && !DECL_USE_TEMPLATE (olddecl))))
3132     /* One of the declarations is a template instantiation, and the
3133        other is not a template at all.  That's OK.  */
3134     return 0;
3135   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3136            && DECL_NAMESPACE_ALIAS (newdecl)
3137            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3138     /* Redeclaration of namespace alias, ignore it. */
3139     return 1;
3140   else
3141     {
3142       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3143       if (errmsg)
3144         {
3145           cp_error (errmsg, newdecl);
3146           if (DECL_NAME (olddecl) != NULL_TREE)
3147             cp_error_at ((DECL_INITIAL (olddecl)
3148                           && namespace_bindings_p ())
3149                          ? "`%#D' previously defined here"
3150                          : "`%#D' previously declared here", olddecl);
3151         }
3152       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3153                && DECL_INITIAL (olddecl) != NULL_TREE
3154                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3155                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3156         {
3157           /* Prototype decl follows defn w/o prototype.  */
3158           cp_warning_at ("prototype for `%#D'", newdecl);
3159           cp_warning_at ("follows non-prototype definition here", olddecl);
3160         }
3161       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3162                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3163         {
3164           /* extern "C" int foo ();
3165              int foo () { bar (); }
3166              is OK.  */
3167           if (current_lang_stack
3168               == &VARRAY_TREE (current_lang_base, 0))
3169             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3170           else
3171             {
3172               cp_error_at ("previous declaration of `%#D' with %L linkage",
3173                            olddecl, DECL_LANGUAGE (olddecl));
3174               cp_error ("conflicts with new declaration with %L linkage",
3175                         DECL_LANGUAGE (newdecl));
3176             }
3177         }
3178
3179       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3180         ;
3181       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3182         {
3183           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3184           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3185           int i = 1;
3186
3187           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3188             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3189
3190           for (; t1 && t1 != void_list_node;
3191                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3192             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3193               {
3194                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3195                                            TREE_PURPOSE (t2)))
3196                   {
3197                     if (pedantic)
3198                       {
3199                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3200                                     i, newdecl);
3201                         cp_pedwarn_at ("after previous specification in `%#D'",
3202                                        olddecl);
3203                       }
3204                   }
3205                 else
3206                   {
3207                     cp_error ("default argument given for parameter %d of `%#D'",
3208                               i, newdecl);
3209                     cp_error_at ("after previous specification in `%#D'",
3210                                  olddecl);
3211                   }
3212               }
3213
3214           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3215               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3216             {
3217               cp_warning ("`%#D' was used before it was declared inline",
3218                           newdecl);
3219               cp_warning_at ("previous non-inline declaration here",
3220                              olddecl);
3221             }
3222         }
3223     }
3224
3225   /* If new decl is `static' and an `extern' was seen previously,
3226      warn about it.  */
3227   warn_extern_redeclared_static (newdecl, olddecl);
3228
3229   /* We have committed to returning 1 at this point.  */
3230   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3231     {
3232       /* Now that functions must hold information normally held
3233          by field decls, there is extra work to do so that
3234          declaration information does not get destroyed during
3235          definition.  */
3236       if (DECL_VINDEX (olddecl))
3237         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3238       if (DECL_VIRTUAL_CONTEXT (olddecl))
3239         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3240       if (DECL_CONTEXT (olddecl))
3241         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3242       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3243         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3244       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3245       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3246       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3247       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3248       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3249       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3250       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3251
3252       /* Optionally warn about more than one declaration for the same
3253          name, but don't warn about a function declaration followed by a
3254          definition.  */
3255       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3256           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3257           /* Don't warn about extern decl followed by definition. */
3258           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3259           /* Don't warn about friends, let add_friend take care of it. */
3260           && ! DECL_FRIEND_P (newdecl))
3261         {
3262           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3263           cp_warning_at ("previous declaration of `%D'", olddecl);
3264         }
3265     }
3266
3267   /* Deal with C++: must preserve virtual function table size.  */
3268   if (TREE_CODE (olddecl) == TYPE_DECL)
3269     {
3270       register tree newtype = TREE_TYPE (newdecl);
3271       register tree oldtype = TREE_TYPE (olddecl);
3272
3273       if (newtype != error_mark_node && oldtype != error_mark_node
3274           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3275         {
3276           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3277           CLASSTYPE_FRIEND_CLASSES (newtype)
3278             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3279         }
3280     }
3281
3282   /* Copy all the DECL_... slots specified in the new decl
3283      except for any that we copy here from the old type.  */
3284   DECL_MACHINE_ATTRIBUTES (newdecl)
3285     = merge_machine_decl_attributes (olddecl, newdecl);
3286
3287   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3288     {
3289       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3290                              DECL_TEMPLATE_RESULT (olddecl)))
3291         cp_error ("invalid redeclaration of %D", newdecl);
3292       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3293       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3294         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3295                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3296
3297       return 1;
3298     }
3299
3300   if (types_match)
3301     {
3302       /* Automatically handles default parameters.  */
3303       tree oldtype = TREE_TYPE (olddecl);
3304       tree newtype;
3305
3306       /* Merge the data types specified in the two decls.  */
3307       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3308
3309       if (TREE_CODE (newdecl) == VAR_DECL)
3310         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3311       /* Do this after calling `common_type' so that default
3312          parameters don't confuse us.  */
3313       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3314           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3315               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3316         {
3317           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3318                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3319           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3320                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3321
3322           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3323               && DECL_SOURCE_LINE (olddecl) != 0
3324               && flag_exceptions
3325               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3326                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3327             {
3328               cp_error ("declaration of `%F' throws different exceptions",
3329                         newdecl);
3330               cp_error_at ("than previous declaration `%F'", olddecl);
3331             }
3332         }
3333       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3334
3335       /* Lay the type out, unless already done.  */
3336       if (! same_type_p (newtype, oldtype)
3337           && TREE_TYPE (newdecl) != error_mark_node
3338           && !(processing_template_decl && uses_template_parms (newdecl)))
3339         layout_type (TREE_TYPE (newdecl));
3340
3341       if ((TREE_CODE (newdecl) == VAR_DECL
3342            || TREE_CODE (newdecl) == PARM_DECL
3343            || TREE_CODE (newdecl) == RESULT_DECL
3344            || TREE_CODE (newdecl) == FIELD_DECL
3345            || TREE_CODE (newdecl) == TYPE_DECL)
3346           && !(processing_template_decl && uses_template_parms (newdecl)))
3347         layout_decl (newdecl, 0);
3348
3349       /* Merge the type qualifiers.  */
3350       if (TREE_READONLY (newdecl))
3351         TREE_READONLY (olddecl) = 1;
3352       if (TREE_THIS_VOLATILE (newdecl))
3353         TREE_THIS_VOLATILE (olddecl) = 1;
3354
3355       /* Merge the initialization information.  */
3356       if (DECL_INITIAL (newdecl) == NULL_TREE
3357           && DECL_INITIAL (olddecl) != NULL_TREE)
3358         {
3359           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3360           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3361           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3362           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3363               && DECL_LANG_SPECIFIC (newdecl)
3364               && DECL_LANG_SPECIFIC (olddecl))
3365             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3366         }
3367
3368       /* Merge the section attribute.
3369          We want to issue an error if the sections conflict but that must be
3370          done later in decl_attributes since we are called before attributes
3371          are assigned.  */
3372       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3373         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3374
3375       /* Keep the old rtl since we can safely use it.  */
3376       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3377
3378       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3379         {
3380           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3381             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3382           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3383             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3384           DECL_NO_LIMIT_STACK (newdecl)
3385             |= DECL_NO_LIMIT_STACK (olddecl);
3386         }
3387     }
3388   /* If cannot merge, then use the new type and qualifiers,
3389      and don't preserve the old rtl.  */
3390   else
3391     {
3392       /* Clean out any memory we had of the old declaration.  */
3393       tree oldstatic = value_member (olddecl, static_aggregates);
3394       if (oldstatic)
3395         TREE_VALUE (oldstatic) = error_mark_node;
3396
3397       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3398       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3399       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3400       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3401     }
3402
3403   /* Merge the storage class information.  */
3404   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3405   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3406   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3407   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3408   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3409   if (! DECL_EXTERNAL (olddecl))
3410     DECL_EXTERNAL (newdecl) = 0;
3411
3412   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3413     {
3414       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3415       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3416       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3417       DECL_TEMPLATE_INSTANTIATED (newdecl)
3418         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3419       /* Don't really know how much of the language-specific
3420          values we should copy from old to new.  */
3421       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3422       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3423       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3424       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3425       olddecl_friend = DECL_FRIEND_P (olddecl);
3426
3427       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3428       if (TREE_CODE (newdecl) == FUNCTION_DECL
3429           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3430         DECL_BEFRIENDING_CLASSES (newdecl)
3431           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3432                      DECL_BEFRIENDING_CLASSES (olddecl));
3433     }
3434
3435   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3436     {
3437       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3438           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3439         {
3440           /* If newdecl is not a specialization, then it is not a
3441              template-related function at all.  And that means that we
3442              shoud have exited above, returning 0.  */
3443           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3444                               0);
3445
3446           if (TREE_USED (olddecl))
3447             /* From [temp.expl.spec]:
3448
3449                If a template, a member template or the member of a class
3450                template is explicitly specialized then that
3451                specialization shall be declared before the first use of
3452                that specialization that would cause an implicit
3453                instantiation to take place, in every translation unit in
3454                which such a use occurs.  */
3455             cp_error ("explicit specialization of %D after first use",
3456                       olddecl);
3457
3458           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3459         }
3460       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3461
3462       /* If either decl says `inline', this fn is inline, unless its
3463          definition was passed already.  */
3464       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3465         DECL_INLINE (olddecl) = 1;
3466       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3467
3468       if (! types_match)
3469         {
3470           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3471           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3472           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3473         }
3474       if (! types_match || new_defines_function)
3475         {
3476           /* These need to be copied so that the names are available.
3477              Note that if the types do match, we'll preserve inline
3478              info and other bits, but if not, we won't.  */
3479           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3480           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3481         }
3482       if (new_defines_function)
3483         /* If defining a function declared with other language
3484            linkage, use the previously declared language linkage.  */
3485         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3486       else if (types_match)
3487         {
3488           /* If redeclaring a builtin function, and not a definition,
3489              it stays built in.  */
3490           if (DECL_BUILT_IN (olddecl))
3491             {
3492               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3493               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3494               /* If we're keeping the built-in definition, keep the rtl,
3495                  regardless of declaration matches.  */
3496               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3497             }
3498           else
3499             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3500
3501           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3502           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3503             /* Previously saved insns go together with
3504                the function's previous definition.  */
3505             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3506           /* Don't clear out the arguments if we're redefining a function.  */
3507           if (DECL_ARGUMENTS (olddecl))
3508             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3509         }
3510       if (DECL_LANG_SPECIFIC (olddecl))
3511         DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
3512     }
3513
3514   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3515     {
3516       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3517     }
3518
3519   /* Now preserve various other info from the definition.  */
3520   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3521   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3522   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3523   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3524
3525   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3526     {
3527       int function_size;
3528
3529       function_size = sizeof (struct tree_decl);
3530
3531       bcopy ((char *) newdecl + sizeof (struct tree_common),
3532              (char *) olddecl + sizeof (struct tree_common),
3533              function_size - sizeof (struct tree_common));
3534
3535       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3536         {
3537           /* If newdecl is a template instantiation, it is possible that
3538              the following sequence of events has occurred:
3539
3540              o A friend function was declared in a class template.  The
3541              class template was instantiated.
3542
3543              o The instantiation of the friend declaration was
3544              recorded on the instantiation list, and is newdecl.
3545
3546              o Later, however, instantiate_class_template called pushdecl
3547              on the newdecl to perform name injection.  But, pushdecl in
3548              turn called duplicate_decls when it discovered that another
3549              declaration of a global function with the same name already
3550              existed.
3551
3552              o Here, in duplicate_decls, we decided to clobber newdecl.
3553
3554              If we're going to do that, we'd better make sure that
3555              olddecl, and not newdecl, is on the list of
3556              instantiations so that if we try to do the instantiation
3557              again we won't get the clobbered declaration.  */
3558
3559           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3560           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3561
3562           for (; decls; decls = TREE_CHAIN (decls))
3563             if (TREE_VALUE (decls) == newdecl)
3564               TREE_VALUE (decls) = olddecl;
3565         }
3566     }
3567   else
3568     {
3569       bcopy ((char *) newdecl + sizeof (struct tree_common),
3570              (char *) olddecl + sizeof (struct tree_common),
3571              sizeof (struct tree_decl) - sizeof (struct tree_common)
3572              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3573     }
3574
3575   DECL_UID (olddecl) = olddecl_uid;
3576   if (olddecl_friend)
3577     DECL_FRIEND_P (olddecl) = 1;
3578
3579   /* NEWDECL contains the merged attribute lists.
3580      Update OLDDECL to be the same.  */
3581   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3582
3583   return 1;
3584 }
3585
3586 /* Record a decl-node X as belonging to the current lexical scope.
3587    Check for errors (such as an incompatible declaration for the same
3588    name already seen in the same scope).
3589
3590    Returns either X or an old decl for the same name.
3591    If an old decl is returned, it may have been smashed
3592    to agree with what X says.  */
3593
3594 tree
3595 pushdecl (x)
3596      tree x;
3597 {
3598   register tree t;
3599   register tree name;
3600   int need_new_binding;
3601
3602   /* We shouldn't be calling pushdecl when we're generating RTL for a
3603      function that we already did semantic analysis on previously.  */
3604   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3605                       19990913);
3606
3607   name = DECL_ASSEMBLER_NAME (x);
3608   need_new_binding = 1;
3609
3610   if (DECL_TEMPLATE_PARM_P (x))
3611     /* Template parameters have no context; they are not X::T even
3612        when declared within a class or namespace.  */
3613     ;
3614   else
3615     {
3616       if (current_function_decl && x != current_function_decl
3617           /* A local declaration for a function doesn't constitute
3618              nesting.  */
3619           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3620           /* A local declaration for an `extern' variable is in the
3621              scoped of the current namespace, not the current
3622              function.  */
3623           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3624           && !DECL_CONTEXT (x))
3625         DECL_CONTEXT (x) = current_function_decl;
3626       if (!DECL_CONTEXT (x))
3627         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3628
3629       /* If this is the declaration for a namespace-scope function,
3630          but the declaration itself is in a local scope, mark the
3631          declaration.  */
3632       if (TREE_CODE (x) == FUNCTION_DECL
3633           && DECL_NAMESPACE_SCOPE_P (x)
3634           && current_function_decl
3635           && x != current_function_decl)
3636         DECL_LOCAL_FUNCTION_P (x) = 1;
3637     }
3638
3639   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3640      compiler wants to use.  */
3641   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3642       || TREE_CODE (x) == NAMESPACE_DECL)
3643     name = DECL_NAME (x);
3644
3645   if (name)
3646     {
3647 #if 0
3648       /* Not needed...see below.  */
3649       char *file;
3650       int line;
3651 #endif
3652       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3653         name = TREE_OPERAND (name, 0);
3654
3655       /* Namespace-scoped variables are not found in the current level. */
3656       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3657         t = namespace_binding (name, DECL_CONTEXT (x));
3658       else
3659         t = lookup_name_current_level (name);
3660       if (t == error_mark_node)
3661         {
3662           /* error_mark_node is 0 for a while during initialization!  */
3663           t = NULL_TREE;
3664           cp_error_at ("`%#D' used prior to declaration", x);
3665         }
3666
3667       else if (t != NULL_TREE)
3668         {
3669 #if 0
3670           /* This is turned off until I have time to do it right (bpk).  */
3671           /* With the code below that uses it...  */
3672           file = DECL_SOURCE_FILE (t);
3673           line = DECL_SOURCE_LINE (t);
3674 #endif
3675           if (TREE_CODE (t) == PARM_DECL)
3676             {
3677               if (DECL_CONTEXT (t) == NULL_TREE)
3678                 fatal ("parse errors have confused me too much");
3679
3680               /* Check for duplicate params.  */
3681               if (duplicate_decls (x, t))
3682                 return t;
3683             }
3684           else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3685                     || DECL_FUNCTION_TEMPLATE_P (x))
3686                    && is_overloaded_fn (t))
3687             /* Don't do anything just yet. */;
3688           else if (t == wchar_decl_node)
3689             {
3690               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3691                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3692
3693               /* Throw away the redeclaration.  */
3694               return t;
3695             }
3696           else if (TREE_CODE (t) != TREE_CODE (x))
3697             {
3698               if (duplicate_decls (x, t))
3699                 return t;
3700             }
3701           else if (duplicate_decls (x, t))
3702             {
3703 #if 0
3704               /* This is turned off until I have time to do it right (bpk).  */
3705
3706               /* Also warn if they did a prototype with `static' on it, but
3707                  then later left the `static' off.  */
3708               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3709                 {
3710                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3711                     return t;
3712
3713                   if (extra_warnings)
3714                     {
3715                       cp_warning ("`static' missing from declaration of `%D'",
3716                                   t);
3717                       warning_with_file_and_line (file, line,
3718                                                   "previous declaration of `%s'",
3719                                                   decl_as_string (t, 0));
3720                     }
3721
3722                   /* Now fix things so it'll do what they expect.  */
3723                   if (current_function_decl)
3724                     TREE_PUBLIC (current_function_decl) = 0;
3725                 }
3726               /* Due to interference in memory reclamation (X may be
3727                  obstack-deallocated at this point), we must guard against
3728                  one really special case.  [jason: This should be handled
3729                  by start_function]  */
3730               if (current_function_decl == x)
3731                 current_function_decl = t;
3732 #endif
3733               if (TREE_CODE (t) == TYPE_DECL)
3734                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3735               else if (TREE_CODE (t) == FUNCTION_DECL)
3736                 check_default_args (t);
3737
3738               return t;
3739             }
3740           else if (DECL_MAIN_P (x))
3741             {
3742               /* A redeclaration of main, but not a duplicate of the
3743                  previous one.
3744
3745                  [basic.start.main]
3746
3747                  This function shall not be overloaded.  */
3748               cp_error_at ("invalid redeclaration of `%D'", t);
3749               cp_error ("as `%D'", x);
3750               /* We don't try to push this declaration since that
3751                  causes a crash.  */
3752               return x;
3753             }
3754         }
3755
3756       check_template_shadow (x);
3757
3758       /* If this is a function conjured up by the backend, massage it
3759          so it looks friendly.  */
3760       if (TREE_CODE (x) == FUNCTION_DECL
3761           && ! DECL_LANG_SPECIFIC (x))
3762         {
3763           retrofit_lang_decl (x);
3764           DECL_LANGUAGE (x) = lang_c;
3765         }
3766
3767       if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3768         {
3769           t = push_overloaded_decl (x, PUSH_LOCAL);
3770           if (t != x)
3771             return t;
3772           if (!namespace_bindings_p ())
3773             /* We do not need to create a binding for this name;
3774                push_overloaded_decl will have already done so if
3775                necessary.  */
3776             need_new_binding = 0;
3777         }
3778       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3779         {
3780           t = push_overloaded_decl (x, PUSH_GLOBAL);
3781           if (t == x)
3782             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3783           return t;
3784         }
3785
3786       /* If declaring a type as a typedef, copy the type (unless we're
3787          at line 0), and install this TYPE_DECL as the new type's typedef
3788          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3789       if (TREE_CODE (x) == TYPE_DECL)
3790         {
3791           tree type = TREE_TYPE (x);
3792           if (DECL_SOURCE_LINE (x) == 0)
3793             {
3794               if (TYPE_NAME (type) == 0)
3795                 TYPE_NAME (type) = x;
3796             }
3797           else if (type != error_mark_node && TYPE_NAME (type) != x
3798                    /* We don't want to copy the type when all we're
3799                       doing is making a TYPE_DECL for the purposes of
3800                       inlining.  */
3801                    && (!TYPE_NAME (type)
3802                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3803             {
3804               DECL_ORIGINAL_TYPE (x) = type;
3805               type = build_type_copy (type);
3806               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3807               TYPE_NAME (type) = x;
3808               TREE_TYPE (x) = type;
3809             }
3810
3811           if (type != error_mark_node
3812               && TYPE_NAME (type)
3813               && TYPE_IDENTIFIER (type))
3814             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3815                                                   current_binding_level);
3816
3817         }
3818
3819       /* Multiple external decls of the same identifier ought to match.
3820
3821          We get warnings about inline functions where they are defined.
3822          We get warnings about other functions from push_overloaded_decl.
3823
3824          Avoid duplicate warnings where they are used.  */
3825       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3826         {
3827           tree decl;
3828
3829           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3830               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3831                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3832             decl = IDENTIFIER_NAMESPACE_VALUE (name);
3833           else
3834             decl = NULL_TREE;
3835
3836           if (decl
3837               /* If different sort of thing, we already gave an error.  */
3838               && TREE_CODE (decl) == TREE_CODE (x)
3839               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3840             {
3841               cp_pedwarn ("type mismatch with previous external decl", x);
3842               cp_pedwarn_at ("previous external decl of `%#D'", decl);
3843             }
3844         }
3845
3846       /* This name is new in its binding level.
3847          Install the new declaration and return it.  */
3848       if (namespace_bindings_p ())
3849         {
3850           /* Install a global value.  */
3851
3852           /* If the first global decl has external linkage,
3853              warn if we later see static one.  */
3854           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3855             TREE_PUBLIC (name) = 1;
3856
3857           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3858                 && t != NULL_TREE)
3859               /* For an ordinary function, we create a binding from
3860                  the mangled name (i.e., NAME) to the DECL.  But, for
3861                  an `extern "C"' function, the mangled name and the
3862                  ordinary name are the same so we need not do this.  */
3863               && !(TREE_CODE (x) == FUNCTION_DECL &&
3864                    DECL_LANGUAGE (x) == lang_c))
3865             {
3866               if (TREE_CODE (x) == FUNCTION_DECL)
3867                 my_friendly_assert
3868                   ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
3869                   || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
3870               SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3871             }
3872
3873           /* Don't forget if the function was used via an implicit decl.  */
3874           if (IDENTIFIER_IMPLICIT_DECL (name)
3875               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3876             TREE_USED (x) = 1;
3877
3878           /* Don't forget if its address was taken in that way.  */
3879           if (IDENTIFIER_IMPLICIT_DECL (name)
3880               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3881             TREE_ADDRESSABLE (x) = 1;
3882
3883           /* Warn about mismatches against previous implicit decl.  */
3884           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
3885               /* If this real decl matches the implicit, don't complain.  */
3886               && ! (TREE_CODE (x) == FUNCTION_DECL
3887                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
3888             cp_warning
3889               ("`%D' was previously implicitly declared to return `int'", x);
3890
3891           /* If new decl is `static' and an `extern' was seen previously,
3892              warn about it.  */
3893           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
3894             warn_extern_redeclared_static (x, t);
3895         }
3896       else
3897         {
3898           /* Here to install a non-global value.  */
3899           tree oldlocal = IDENTIFIER_VALUE (name);
3900           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
3901
3902           if (need_new_binding)
3903             {
3904               push_local_binding (name, x, 0);
3905               /* Because push_local_binding will hook X on to the
3906                  current_binding_level's name list, we don't want to
3907                  do that again below.  */
3908               need_new_binding = 0;
3909             }
3910
3911           /* If this is a TYPE_DECL, push it into the type value slot.  */
3912           if (TREE_CODE (x) == TYPE_DECL)
3913             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
3914                                                   current_binding_level);
3915
3916           /* Clear out any TYPE_DECL shadowed by a namespace so that
3917              we won't think this is a type.  The C struct hack doesn't
3918              go through namespaces.  */
3919           if (TREE_CODE (x) == NAMESPACE_DECL)
3920             set_identifier_type_value_with_scope (name, NULL_TREE,
3921                                                   current_binding_level);
3922
3923           if (oldlocal)
3924             {
3925               tree d = oldlocal;
3926               while (oldlocal
3927                      && TREE_CODE (oldlocal) == VAR_DECL
3928                      && DECL_DEAD_FOR_LOCAL (oldlocal))
3929                 {
3930                   oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
3931                 }
3932               if (oldlocal == NULL_TREE)
3933                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
3934             }
3935
3936           /* If this is an extern function declaration, see if we
3937              have a global definition or declaration for the function.  */
3938           if (oldlocal == NULL_TREE
3939               && DECL_EXTERNAL (x)
3940               && oldglobal != NULL_TREE
3941               && TREE_CODE (x) == FUNCTION_DECL
3942               && TREE_CODE (oldglobal) == FUNCTION_DECL)
3943             {
3944               /* We have one.  Their types must agree.  */
3945               if (decls_match (x, oldglobal))
3946                 /* OK */;
3947               else
3948                 {
3949                   cp_warning ("extern declaration of `%#D' doesn't match", x);
3950                   cp_warning_at ("global declaration `%#D'", oldglobal);
3951                 }
3952             }
3953           /* If we have a local external declaration,
3954              and no file-scope declaration has yet been seen,
3955              then if we later have a file-scope decl it must not be static.  */
3956           if (oldlocal == NULL_TREE
3957               && oldglobal == NULL_TREE
3958               && DECL_EXTERNAL (x)
3959               && TREE_PUBLIC (x))
3960             TREE_PUBLIC (name) = 1;
3961
3962           /* Warn if shadowing an argument at the top level of the body.  */
3963           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
3964               /* Inline decls shadow nothing.  */
3965               && !DECL_FROM_INLINE (x)
3966               && TREE_CODE (oldlocal) == PARM_DECL
3967               /* Don't complain if it's from an enclosing function.  */
3968               && DECL_CONTEXT (oldlocal) == current_function_decl
3969               && TREE_CODE (x) != PARM_DECL)
3970             {
3971               /* Go to where the parms should be and see if we
3972                  find them there.  */
3973               struct binding_level *b = current_binding_level->level_chain;
3974
3975               if (cleanup_label)
3976                 b = b->level_chain;
3977
3978               /* ARM $8.3 */
3979               if (b->parm_flag == 1)
3980                 cp_error ("declaration of `%#D' shadows a parameter", name);
3981             }
3982
3983           /* Maybe warn if shadowing something else.  */
3984           if (warn_shadow && !DECL_EXTERNAL (x)
3985               /* Inline decls shadow nothing.  */
3986               && !DECL_FROM_INLINE (x)
3987               /* No shadow warnings for internally generated vars.  */
3988               && ! DECL_ARTIFICIAL (x)
3989               /* No shadow warnings for vars made for inlining.  */
3990               && ! DECL_FROM_INLINE (x))
3991             {
3992               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
3993                 warning ("declaration of `%s' shadows a parameter",
3994                         IDENTIFIER_POINTER (name));
3995               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
3996                        && current_class_ptr
3997                        && !TREE_STATIC (name))
3998                 warning ("declaration of `%s' shadows a member of `this'",
3999                         IDENTIFIER_POINTER (name));
4000               else if (oldlocal != NULL_TREE)
4001                 warning ("declaration of `%s' shadows previous local",
4002                         IDENTIFIER_POINTER (name));
4003               else if (oldglobal != NULL_TREE)
4004                 /* XXX shadow warnings in outer-more namespaces */
4005                 warning ("declaration of `%s' shadows global declaration",
4006                         IDENTIFIER_POINTER (name));
4007             }
4008         }
4009
4010       if (TREE_CODE (x) == FUNCTION_DECL)
4011         check_default_args (x);
4012
4013       /* Keep count of variables in this level with incomplete type.  */
4014       if (TREE_CODE (x) == VAR_DECL
4015           && TREE_TYPE (x) != error_mark_node
4016           && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
4017                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4018               /* RTTI TD entries are created while defining the type_info.  */
4019               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4020                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4021         {
4022           if (namespace_bindings_p ())
4023             namespace_scope_incomplete
4024               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4025           else
4026             current_binding_level->incomplete
4027               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4028         }
4029     }
4030
4031   if (need_new_binding)
4032     add_decl_to_level (x,
4033                        DECL_NAMESPACE_SCOPE_P (x)
4034                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4035                        : current_binding_level);
4036
4037   return x;
4038 }
4039
4040 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4041    caller to set DECL_CONTEXT properly.  */
4042
4043 static tree
4044 pushdecl_with_scope (x, level)
4045      tree x;
4046      struct binding_level *level;
4047 {
4048   register struct binding_level *b;
4049   tree function_decl = current_function_decl;
4050
4051   current_function_decl = NULL_TREE;
4052   if (level->parm_flag == 2)
4053     {
4054       b = class_binding_level;
4055       class_binding_level = level;
4056       pushdecl_class_level (x);
4057       class_binding_level = b;
4058     }
4059   else
4060     {
4061       b = current_binding_level;
4062       current_binding_level = level;
4063       x = pushdecl (x);
4064       current_binding_level = b;
4065     }
4066   current_function_decl = function_decl;
4067   return x;
4068 }
4069
4070 /* Like pushdecl, only it places X in the current namespace,
4071    if appropriate.  */
4072
4073 tree
4074 pushdecl_namespace_level (x)
4075      tree x;
4076 {
4077   register struct binding_level *b = current_binding_level;
4078   register tree t;
4079
4080   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4081
4082   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4083      what we want.  */
4084   if (TREE_CODE (x) == TYPE_DECL)
4085     {
4086       tree name = DECL_NAME (x);
4087       tree newval;
4088       tree *ptr = (tree *)0;
4089       for (; b != global_binding_level; b = b->level_chain)
4090         {
4091           tree shadowed = b->type_shadowed;
4092           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4093             if (TREE_PURPOSE (shadowed) == name)
4094               {
4095                 ptr = &TREE_VALUE (shadowed);
4096                 /* Can't break out of the loop here because sometimes
4097                    a binding level will have duplicate bindings for
4098                    PT names.  It's gross, but I haven't time to fix it.  */
4099               }
4100         }
4101       newval = TREE_TYPE (x);
4102       if (ptr == (tree *)0)
4103         {
4104           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4105              up here if this is changed to an assertion.  --KR  */
4106           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4107         }
4108       else
4109         {
4110           *ptr = newval;
4111         }
4112     }
4113   return t;
4114 }
4115
4116 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4117    if appropriate.  */
4118
4119 tree
4120 pushdecl_top_level (x)
4121      tree x;
4122 {
4123   push_to_top_level ();
4124   x = pushdecl_namespace_level (x);
4125   pop_from_top_level ();
4126   return x;
4127 }
4128
4129 /* Make the declaration of X appear in CLASS scope.  */
4130
4131 void
4132 pushdecl_class_level (x)
4133      tree x;
4134 {
4135   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4136      scope looks for the pre-mangled name.  */
4137   register tree name;
4138
4139   if (TREE_CODE (x) == OVERLOAD)
4140     x = OVL_CURRENT (x);
4141   name = DECL_NAME (x);
4142
4143   if (name)
4144     {
4145       push_class_level_binding (name, x);
4146       if (TREE_CODE (x) == TYPE_DECL)
4147         set_identifier_type_value (name, TREE_TYPE (x));
4148     }
4149   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4150     {
4151       tree f;
4152
4153       for (f = TYPE_FIELDS (TREE_TYPE (x));
4154            f;
4155            f = TREE_CHAIN (f))
4156         pushdecl_class_level (f);
4157     }
4158 }
4159
4160 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4161    DECL, or a modified version thereof.  */
4162
4163 tree
4164 maybe_push_decl (decl)
4165      tree decl;
4166 {
4167   tree type = TREE_TYPE (decl);
4168
4169   /* Add this decl to the current binding level, but not if it comes
4170      from another scope, e.g. a static member variable.  TEM may equal
4171      DECL or it may be a previous decl of the same name.  */
4172   if (decl == error_mark_node
4173       || (TREE_CODE (decl) != PARM_DECL
4174           && DECL_CONTEXT (decl) != NULL_TREE
4175           /* Definitions of namespace members outside their namespace are
4176              possible. */
4177           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4178       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4179       || TREE_CODE (type) == UNKNOWN_TYPE
4180       /* The declaration of a template specialization does not affect
4181          the functions available for overload resolution, so we do not
4182          call pushdecl.  */
4183       || (TREE_CODE (decl) == FUNCTION_DECL
4184           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4185     return decl;
4186   else
4187     return pushdecl (decl);
4188 }
4189
4190 #if 0
4191 /* This function is used to push the mangled decls for nested types into
4192    the appropriate scope.  Previously pushdecl_top_level was used, but that
4193    is incorrect for members of local classes.  */
4194
4195 void
4196 pushdecl_nonclass_level (x)
4197      tree x;
4198 {
4199   struct binding_level *b = current_binding_level;
4200
4201   my_friendly_assert (b->parm_flag != 2, 180);
4202
4203 #if 0
4204   /* Get out of template binding levels */
4205   while (b->pseudo_global)
4206     b = b->level_chain;
4207 #endif
4208
4209   pushdecl_with_scope (x, b);
4210 }
4211 #endif
4212
4213 /* Make the declaration(s) of X appear in CLASS scope
4214    under the name NAME.  */
4215
4216 void
4217 push_class_level_binding (name, x)
4218      tree name;
4219      tree x;
4220 {
4221   tree binding;
4222   /* The class_binding_level will be NULL if x is a template
4223      parameter name in a member template.  */
4224   if (!class_binding_level)
4225     return;
4226
4227   /* Make sure that this new member does not have the same name
4228      as a template parameter.  */
4229   if (TYPE_BEING_DEFINED (current_class_type))
4230     check_template_shadow (x);
4231
4232   /* If this declaration shadows a declaration from an enclosing
4233      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4234      we leave this class.  Record the shadowed declaration here.  */
4235   binding = IDENTIFIER_BINDING (name);
4236   if (binding
4237       && ((TREE_CODE (x) == OVERLOAD
4238            && BINDING_VALUE (binding)
4239            && is_overloaded_fn (BINDING_VALUE (binding)))
4240           || INHERITED_VALUE_BINDING_P (binding)))
4241     {
4242       tree shadow;
4243       tree old_decl;
4244
4245       /* If the old binding was from a base class, and was for a tag
4246          name, slide it over to make room for the new binding.  The
4247          old binding is still visible if explicitly qualified with a
4248          class-key.  */
4249       if (INHERITED_VALUE_BINDING_P (binding)
4250           && BINDING_VALUE (binding)
4251           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4252           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4253           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4254         {
4255           old_decl = BINDING_TYPE (binding);
4256           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4257           BINDING_VALUE (binding) = NULL_TREE;
4258           INHERITED_VALUE_BINDING_P (binding) = 0;
4259         }
4260       else
4261         old_decl = BINDING_VALUE (binding);
4262
4263       /* There was already a binding for X containing fewer
4264          functions than are named in X.  Find the previous
4265          declaration of X on the class-shadowed list, and update it.  */
4266       for (shadow = class_binding_level->class_shadowed;
4267            shadow;
4268            shadow = TREE_CHAIN (shadow))
4269         if (TREE_PURPOSE (shadow) == name
4270             && TREE_TYPE (shadow) == old_decl)
4271           {
4272             BINDING_VALUE (binding) = x;
4273             INHERITED_VALUE_BINDING_P (binding) = 0;
4274             TREE_TYPE (shadow) = x;
4275             return;
4276           }
4277     }
4278
4279   /* If we didn't replace an existing binding, put the binding on the
4280      stack of bindings for the identifier, and update
4281      IDENTIFIER_CLASS_VALUE.  */
4282   if (push_class_binding (name, x))
4283     {
4284       class_binding_level->class_shadowed
4285         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4286                      class_binding_level->class_shadowed);
4287       /* Record the value we are binding NAME to so that we can know
4288          what to pop later.  */
4289       TREE_TYPE (class_binding_level->class_shadowed) = x;
4290     }
4291 }
4292
4293 /* Insert another USING_DECL into the current binding level,
4294    returning this declaration. If this is a redeclaration,
4295    do nothing and return NULL_TREE.  */
4296
4297 tree
4298 push_using_decl (scope, name)
4299      tree scope;
4300      tree name;
4301 {
4302   tree decl;
4303
4304   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4305   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4306   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4307     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4308       break;
4309   if (decl)
4310     return NULL_TREE;
4311   decl = build_lang_decl (USING_DECL, name, void_type_node);
4312   DECL_INITIAL (decl) = scope;
4313   TREE_CHAIN (decl) = current_binding_level->usings;
4314   current_binding_level->usings = decl;
4315   return decl;
4316 }
4317
4318 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4319    changed (i.e. there was already a directive), or the fresh
4320    TREE_LIST otherwise.  */
4321
4322 tree
4323 push_using_directive (used)
4324      tree used;
4325 {
4326   tree ud = current_binding_level->using_directives;
4327   tree iter, ancestor;
4328
4329   /* Check if we already have this. */
4330   if (purpose_member (used, ud) != NULL_TREE)
4331     return NULL_TREE;
4332
4333   /* Recursively add all namespaces used. */
4334   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4335     push_using_directive (TREE_PURPOSE (iter));
4336
4337   ancestor = namespace_ancestor (current_decl_namespace (), used);
4338   ud = current_binding_level->using_directives;
4339   ud = tree_cons (used, ancestor, ud);
4340   current_binding_level->using_directives = ud;
4341   return ud;
4342 }
4343
4344 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4345    other definitions already in place.  We get around this by making
4346    the value of the identifier point to a list of all the things that
4347    want to be referenced by that name.  It is then up to the users of
4348    that name to decide what to do with that list.
4349
4350    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4351    slot.  It is dealt with the same way.
4352
4353    FLAGS is a bitwise-or of the following values:
4354      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4355                  namespace scope.
4356      PUSH_USING: DECL is being pushed as the result of a using
4357                  declaration.
4358
4359    The value returned may be a previous declaration if we guessed wrong
4360    about what language DECL should belong to (C or C++).  Otherwise,
4361    it's always DECL (and never something that's not a _DECL).  */
4362
4363 tree
4364 push_overloaded_decl (decl, flags)
4365      tree decl;
4366      int flags;
4367 {
4368   tree name = DECL_NAME (decl);
4369   tree old;
4370   tree new_binding;
4371   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4372
4373   if (doing_global)
4374     old = namespace_binding (name, DECL_CONTEXT (decl));
4375   else
4376     old = lookup_name_current_level (name);
4377
4378   if (old)
4379     {
4380       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4381         {
4382           tree t = TREE_TYPE (old);
4383           if (IS_AGGR_TYPE (t) && warn_shadow
4384               && (! DECL_IN_SYSTEM_HEADER (decl)
4385                   || ! DECL_IN_SYSTEM_HEADER (old)))
4386             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4387           old = NULL_TREE;
4388         }
4389       else if (is_overloaded_fn (old))
4390         {
4391           tree tmp;
4392
4393           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4394             {
4395               tree fn = OVL_CURRENT (tmp);
4396
4397               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4398                   && !(flags & PUSH_USING)
4399                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4400                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4401                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4402                           decl, fn);
4403
4404               if (duplicate_decls (decl, fn))
4405                 return fn;
4406             }
4407         }
4408       else
4409         {
4410           cp_error_at ("previous non-function declaration `%#D'", old);
4411           cp_error ("conflicts with function declaration `%#D'", decl);
4412           return decl;
4413         }
4414     }
4415
4416   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4417     {
4418       if (old && TREE_CODE (old) != OVERLOAD)
4419         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4420       else
4421         new_binding = ovl_cons (decl, old);
4422       if (flags & PUSH_USING)
4423         OVL_USED (new_binding) = 1;
4424     }
4425   else
4426     /* NAME is not ambiguous.  */
4427     new_binding = decl;
4428
4429   if (doing_global)
4430     set_namespace_binding (name, current_namespace, new_binding);
4431   else
4432     {
4433       /* We only create an OVERLOAD if there was a previous binding at
4434          this level, or if decl is a template. In the former case, we
4435          need to remove the old binding and replace it with the new
4436          binding.  We must also run through the NAMES on the binding
4437          level where the name was bound to update the chain.  */
4438
4439       if (TREE_CODE (new_binding) == OVERLOAD && old)
4440         {
4441           tree *d;
4442
4443           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4444                *d;
4445                d = &TREE_CHAIN (*d))
4446             if (*d == old
4447                 || (TREE_CODE (*d) == TREE_LIST
4448                     && TREE_VALUE (*d) == old))
4449               {
4450                 if (TREE_CODE (*d) == TREE_LIST)
4451                   /* Just replace the old binding with the new.  */
4452                   TREE_VALUE (*d) = new_binding;
4453                 else
4454                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4455                   *d = tree_cons (NULL_TREE, new_binding,
4456                                   TREE_CHAIN (*d));
4457
4458                 /* And update the CPLUS_BINDING node.  */
4459                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4460                   = new_binding;
4461                 return decl;
4462               }
4463
4464           /* We should always find a previous binding in this case.  */
4465           my_friendly_abort (0);
4466         }
4467
4468       /* Install the new binding.  */
4469       push_local_binding (name, new_binding, flags);
4470     }
4471
4472   return decl;
4473 }
4474 \f
4475 /* Generate an implicit declaration for identifier FUNCTIONID
4476    as a function of type int ().  Print a warning if appropriate.  */
4477
4478 tree
4479 implicitly_declare (functionid)
4480      tree functionid;
4481 {
4482   register tree decl;
4483
4484   /* We used to reuse an old implicit decl here,
4485      but this loses with inline functions because it can clobber
4486      the saved decl chains.  */
4487   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4488
4489   DECL_EXTERNAL (decl) = 1;
4490   TREE_PUBLIC (decl) = 1;
4491
4492   /* ISO standard says implicit declarations are in the innermost block.
4493      So we record the decl in the standard fashion.  */
4494   pushdecl (decl);
4495   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4496
4497   if (warn_implicit
4498       /* Only one warning per identifier.  */
4499       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4500     {
4501       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4502     }
4503
4504   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4505
4506   return decl;
4507 }
4508
4509 /* Return zero if the declaration NEWDECL is valid
4510    when the declaration OLDDECL (assumed to be for the same name)
4511    has already been seen.
4512    Otherwise return an error message format string with a %s
4513    where the identifier should go.  */
4514
4515 static const char *
4516 redeclaration_error_message (newdecl, olddecl)
4517      tree newdecl, olddecl;
4518 {
4519   if (TREE_CODE (newdecl) == TYPE_DECL)
4520     {
4521       /* Because C++ can put things into name space for free,
4522          constructs like "typedef struct foo { ... } foo"
4523          would look like an erroneous redeclaration.  */
4524       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4525         return 0;
4526       else
4527         return "redefinition of `%#D'";
4528     }
4529   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4530     {
4531       /* If this is a pure function, its olddecl will actually be
4532          the original initialization to `0' (which we force to call
4533          abort()).  Don't complain about redefinition in this case.  */
4534       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4535         return 0;
4536
4537       /* If both functions come from different namespaces, this is not
4538          a redeclaration - this is a conflict with a used function. */
4539       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4540           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4541         return "`%D' conflicts with used function";
4542
4543       /* We'll complain about linkage mismatches in
4544          warn_extern_redeclared_static.  */
4545
4546       /* Defining the same name twice is no good.  */
4547       if (DECL_INITIAL (olddecl) != NULL_TREE
4548           && DECL_INITIAL (newdecl) != NULL_TREE)
4549         {
4550           if (DECL_NAME (olddecl) == NULL_TREE)
4551             return "`%#D' not declared in class";
4552           else
4553             return "redefinition of `%#D'";
4554         }
4555       return 0;
4556     }
4557   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4558     {
4559       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4560            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4561            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4562           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4563               && TYPE_SIZE (TREE_TYPE (newdecl))
4564               && TYPE_SIZE (TREE_TYPE (olddecl))))
4565         return "redefinition of `%#D'";
4566       return 0;
4567     }
4568   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4569     {
4570       /* Objects declared at top level:  */
4571       /* If at least one is a reference, it's ok.  */
4572       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4573         return 0;
4574       /* Reject two definitions.  */
4575       return "redefinition of `%#D'";
4576     }
4577   else
4578     {
4579       /* Objects declared with block scope:  */
4580       /* Reject two definitions, and reject a definition
4581          together with an external reference.  */
4582       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4583         return "redeclaration of `%#D'";
4584       return 0;
4585     }
4586 }
4587 \f
4588 /* Create a new label, named ID.  */
4589
4590 static tree
4591 make_label_decl (id, local_p)
4592      tree id;
4593      int local_p;
4594 {
4595   tree decl;
4596
4597   decl = build_decl (LABEL_DECL, id, void_type_node);
4598   if (expanding_p)
4599     /* Make sure every label has an rtx.  */
4600     label_rtx (decl);
4601
4602   DECL_CONTEXT (decl) = current_function_decl;
4603   DECL_MODE (decl) = VOIDmode;
4604   C_DECLARED_LABEL_FLAG (decl) = local_p;
4605
4606   /* Say where one reference is to the label, for the sake of the
4607      error if it is not defined.  */
4608   DECL_SOURCE_LINE (decl) = lineno;
4609   DECL_SOURCE_FILE (decl) = input_filename;
4610
4611   /* Record the fact that this identifier is bound to this label.  */
4612   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4613
4614   /* Record this label on the list of used labels so that we can check
4615      at the end of the function to see whether or not the label was
4616      actually defined.  */
4617   if ((named_label_uses == NULL || named_label_uses->label_decl != decl)
4618       && (named_label_uses == NULL
4619           || named_label_uses->names_in_scope != current_binding_level->names
4620           || named_label_uses->label_decl != decl))
4621     {
4622       struct named_label_list *new_ent;
4623       new_ent
4624         = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4625       new_ent->label_decl = decl;
4626       new_ent->names_in_scope = current_binding_level->names;
4627       new_ent->binding_level = current_binding_level;
4628       new_ent->lineno_o_goto = lineno;
4629       new_ent->filename_o_goto = input_filename;
4630       new_ent->next = named_label_uses;
4631       named_label_uses = new_ent;
4632     }
4633
4634   return decl;
4635 }
4636
4637 /* Look for a label named ID in the current function.  If one cannot
4638    be found, create one.  (We keep track of used, but undefined,
4639    labels, and complain about them at the end of a function.)  */
4640
4641 tree
4642 lookup_label (id)
4643      tree id;
4644 {
4645   tree decl;
4646
4647   /* You can't use labels at global scope.  */
4648   if (current_function_decl == NULL_TREE)
4649     {
4650       error ("label `%s' referenced outside of any function",
4651              IDENTIFIER_POINTER (id));
4652       return NULL_TREE;
4653     }
4654
4655   /* See if we've already got this label.  */
4656   decl = IDENTIFIER_LABEL_VALUE (id);
4657   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4658     return decl;
4659
4660   /* Record this label on the list of labels used in this function.
4661      We do this before calling make_label_decl so that we get the
4662      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4663   named_labels = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4664                             named_labels);
4665   /* We need a new label.  */
4666   decl = make_label_decl (id, /*local_p=*/0);
4667   /* Now fill in the information we didn't have before.  */
4668   TREE_VALUE (named_labels) = decl;
4669
4670   return decl;
4671 }
4672
4673 /* Declare a local label named ID.  */
4674
4675 tree
4676 declare_local_label (id)
4677      tree id;
4678 {
4679   tree decl;
4680
4681   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4682      this scope we can restore the old value of
4683      IDENTIFIER_TYPE_VALUE.  */
4684   current_binding_level->shadowed_labels
4685     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4686                  current_binding_level->shadowed_labels);
4687   /* Look for the label.  */
4688   decl = make_label_decl (id, /*local_p=*/1);
4689   /* Now fill in the information we didn't have before.  */
4690   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4691
4692   return decl;
4693 }
4694
4695 /* Define a label, specifying the location in the source file.
4696    Return the LABEL_DECL node for the label, if the definition is valid.
4697    Otherwise return 0.  */
4698
4699 tree
4700 define_label (filename, line, name)
4701      char *filename;
4702      int line;
4703      tree name;
4704 {
4705   tree decl = lookup_label (name);
4706
4707   /* After labels, make any new cleanups go into their
4708      own new (temporary) binding contour.  */
4709   current_binding_level->more_cleanups_ok = 0;
4710
4711   if (name == get_identifier ("wchar_t"))
4712     cp_pedwarn ("label named wchar_t");
4713
4714   if (DECL_INITIAL (decl) != NULL_TREE)
4715     {
4716       cp_error ("duplicate label `%D'", decl);
4717       return 0;
4718     }
4719   else
4720     {
4721       struct named_label_list *uses, *prev;
4722       int identified = 0;
4723       int saw_eh = 0;
4724
4725       /* Mark label as having been defined.  */
4726       DECL_INITIAL (decl) = error_mark_node;
4727       /* Say where in the source.  */
4728       DECL_SOURCE_FILE (decl) = filename;
4729       DECL_SOURCE_LINE (decl) = line;
4730
4731       prev = NULL;
4732       uses = named_label_uses;
4733       while (uses != NULL)
4734         if (uses->label_decl == decl)
4735           {
4736             struct binding_level *b = current_binding_level;
4737             while (b)
4738               {
4739                 tree new_decls = b->names;
4740                 tree old_decls = (b == uses->binding_level)
4741                                   ? uses->names_in_scope : NULL_TREE;
4742                 while (new_decls != old_decls)
4743                   {
4744                     if (TREE_CODE (new_decls) == VAR_DECL
4745                         /* Don't complain about crossing initialization
4746                            of internal entities.  They can't be accessed,
4747                            and they should be cleaned up
4748                            by the time we get to the label.  */
4749                         && ! DECL_ARTIFICIAL (new_decls)
4750                         && !(DECL_INITIAL (new_decls) == NULL_TREE
4751                              && pod_type_p (TREE_TYPE (new_decls))))
4752                       {
4753                         /* This is really only important if we're crossing
4754                            an initialization.  The POD stuff is just
4755                            pedantry; why should it matter if the class
4756                            contains a field of pointer to member type?  */
4757                         int problem = (DECL_INITIAL (new_decls)
4758                                        || (TYPE_NEEDS_CONSTRUCTING
4759                                            (TREE_TYPE (new_decls))));
4760
4761                         if (! identified)
4762                           {
4763                             if (problem)
4764                               {
4765                                 cp_error ("jump to label `%D'", decl);
4766                                 error_with_file_and_line
4767                                   (uses->filename_o_goto,
4768                                    uses->lineno_o_goto, "  from here");
4769                               }
4770                             else
4771                               {
4772                                 cp_pedwarn ("jump to label `%D'", decl);
4773                                 pedwarn_with_file_and_line
4774                                   (uses->filename_o_goto,
4775                                    uses->lineno_o_goto, "  from here");
4776                               }
4777                             identified = 1;
4778                           }
4779
4780                         if (problem)
4781                           cp_error_at ("  crosses initialization of `%#D'",
4782                                        new_decls);
4783                         else
4784                           cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4785                                          new_decls);
4786                       }
4787                     new_decls = TREE_CHAIN (new_decls);
4788                   }
4789                 if (b == uses->binding_level)
4790                   break;
4791                 if (b->eh_region && ! saw_eh)
4792                   {
4793                     if (! identified)
4794                       {
4795                         cp_error ("jump to label `%D'", decl);
4796                         error_with_file_and_line
4797                           (uses->filename_o_goto,
4798                            uses->lineno_o_goto, "  from here");
4799                         identified = 1;
4800                       }
4801                     error ("  enters exception handling block");
4802                     saw_eh = 1;
4803                   }
4804                 b = b->level_chain;
4805               }
4806
4807             if (prev != NULL)
4808               prev->next = uses->next;
4809             else
4810               named_label_uses = uses->next;
4811
4812             uses = uses->next;
4813           }
4814         else
4815           {
4816             prev = uses;
4817             uses = uses->next;
4818           }
4819       current_function_return_value = NULL_TREE;
4820       return decl;
4821     }
4822 }
4823
4824 struct cp_switch
4825 {
4826   struct binding_level *level;
4827   struct cp_switch *next;
4828 };
4829
4830 static struct cp_switch *switch_stack;
4831
4832 void
4833 push_switch ()
4834 {
4835   struct cp_switch *p
4836     = (struct cp_switch *) oballoc (sizeof (struct cp_switch));
4837   p->level = current_binding_level;
4838   p->next = switch_stack;
4839   switch_stack = p;
4840 }
4841
4842 void
4843 pop_switch ()
4844 {
4845   switch_stack = switch_stack->next;
4846 }
4847
4848 /* Note that we've seen a definition of a case label, and complain if this
4849    is a bad place for one.  */
4850
4851 void
4852 define_case_label ()
4853 {
4854   tree cleanup = last_cleanup_this_contour ();
4855   struct binding_level *b = current_binding_level;
4856   int identified = 0;
4857
4858   if (! switch_stack)
4859     /* Don't crash; we'll complain in do_case.  */
4860     return;
4861
4862   if (cleanup)
4863     {
4864       static int explained = 0;
4865       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4866       warning ("where case label appears here");
4867       if (!explained)
4868         {
4869           warning ("(enclose actions of previous case statements requiring");
4870           warning ("destructors in their own binding contours.)");
4871           explained = 1;
4872         }
4873     }
4874
4875   for (; b && b != switch_stack->level; b = b->level_chain)
4876     {
4877       tree new_decls = b->names;
4878       for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4879         {
4880           if (TREE_CODE (new_decls) == VAR_DECL
4881               /* Don't complain about crossing initialization
4882                  of internal entities.  They can't be accessed,
4883                  and they should be cleaned up
4884                  by the time we get to the label.  */
4885               && ! DECL_ARTIFICIAL (new_decls)
4886               && ((DECL_INITIAL (new_decls) != NULL_TREE
4887                    && DECL_INITIAL (new_decls) != error_mark_node)
4888                   || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4889             {
4890               if (! identified)
4891                 error ("jump to case label");
4892               identified = 1;
4893               cp_error_at ("  crosses initialization of `%#D'",
4894                            new_decls);
4895             }
4896         }
4897     }
4898
4899   /* After labels, make any new cleanups go into their
4900      own new (temporary) binding contour.  */
4901
4902   current_binding_level->more_cleanups_ok = 0;
4903   current_function_return_value = NULL_TREE;
4904 }
4905 \f
4906 /* Return the list of declarations of the current level.
4907    Note that this list is in reverse order unless/until
4908    you nreverse it; and when you do nreverse it, you must
4909    store the result back using `storedecls' or you will lose.  */
4910
4911 tree
4912 getdecls ()
4913 {
4914   return current_binding_level->names;
4915 }
4916
4917 /* Return the list of type-tags (for structs, etc) of the current level.  */
4918
4919 tree
4920 gettags ()
4921 {
4922   return current_binding_level->tags;
4923 }
4924
4925 /* Store the list of declarations of the current level.
4926    This is done for the parameter declarations of a function being defined,
4927    after they are modified in the light of any missing parameters.  */
4928
4929 static void
4930 storedecls (decls)
4931      tree decls;
4932 {
4933   current_binding_level->names = decls;
4934 }
4935
4936 /* Similarly, store the list of tags of the current level.  */
4937
4938 void
4939 storetags (tags)
4940      tree tags;
4941 {
4942   current_binding_level->tags = tags;
4943 }
4944 \f
4945 /* Given NAME, an IDENTIFIER_NODE,
4946    return the structure (or union or enum) definition for that name.
4947    Searches binding levels from BINDING_LEVEL up to the global level.
4948    If THISLEVEL_ONLY is nonzero, searches only the specified context
4949    (but skips any tag-transparent contexts to find one that is
4950    meaningful for tags).
4951    FORM says which kind of type the caller wants;
4952    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4953    If the wrong kind of type is found, and it's not a template, an error is
4954    reported.  */
4955
4956 static tree
4957 lookup_tag (form, name, binding_level, thislevel_only)
4958      enum tree_code form;
4959      tree name;
4960      struct binding_level *binding_level;
4961      int thislevel_only;
4962 {
4963   register struct binding_level *level;
4964   /* Non-zero if, we should look past a pseudo-global level, even if
4965      THISLEVEL_ONLY.  */
4966   int allow_pseudo_global = 1;
4967
4968   for (level = binding_level; level; level = level->level_chain)
4969     {
4970       register tree tail;
4971       if (ANON_AGGRNAME_P (name))
4972         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4973           {
4974             /* There's no need for error checking here, because
4975                anon names are unique throughout the compilation.  */
4976             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
4977               return TREE_VALUE (tail);
4978           }
4979       else if (level->namespace_p)
4980         /* Do namespace lookup. */
4981         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
4982           {
4983             tree old = binding_for_name (name, tail);
4984
4985             /* If we just skipped past a pseudo global level, even
4986                though THISLEVEL_ONLY, and we find a template class
4987                declaration, then we use the _TYPE node for the
4988                template.  See the example below.  */
4989             if (thislevel_only && !allow_pseudo_global
4990                 && old && BINDING_VALUE (old)
4991                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
4992               old = TREE_TYPE (BINDING_VALUE (old));
4993             else
4994               old = BINDING_TYPE (old);
4995
4996             /* If it has an original type, it is a typedef, and we
4997                should not return it.  */
4998             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
4999               old = NULL_TREE;
5000             if (old && TREE_CODE (old) != form
5001                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5002               {
5003                 cp_error ("`%#D' redeclared as %C", old, form);
5004                 return NULL_TREE;
5005               }
5006             if (old)
5007               return old;
5008             if (thislevel_only || tail == global_namespace)
5009               return NULL_TREE;
5010           }
5011       else
5012         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5013           {
5014             if (TREE_PURPOSE (tail) == name)
5015               {
5016                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5017                 /* Should tighten this up; it'll probably permit
5018                    UNION_TYPE and a struct template, for example.  */
5019                 if (code != form
5020                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5021                   {
5022                     /* Definition isn't the kind we were looking for.  */
5023                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5024                               form);
5025                     return NULL_TREE;
5026                   }
5027                 return TREE_VALUE (tail);
5028               }
5029           }
5030       if (thislevel_only && ! level->tag_transparent)
5031         {
5032           if (level->pseudo_global && allow_pseudo_global)
5033             {
5034               /* We must deal with cases like this:
5035
5036                    template <class T> struct S;
5037                    template <class T> struct S {};
5038
5039                  When looking up `S', for the second declaration, we
5040                  would like to find the first declaration.  But, we
5041                  are in the pseudo-global level created for the
5042                  template parameters, rather than the (surrounding)
5043                  namespace level.  Thus, we keep going one more level,
5044                  even though THISLEVEL_ONLY is non-zero.  */
5045               allow_pseudo_global = 0;
5046               continue;
5047             }
5048           else
5049             return NULL_TREE;
5050         }
5051     }
5052   return NULL_TREE;
5053 }
5054
5055 #if 0
5056 void
5057 set_current_level_tags_transparency (tags_transparent)
5058      int tags_transparent;
5059 {
5060   current_binding_level->tag_transparent = tags_transparent;
5061 }
5062 #endif
5063
5064 /* Given a type, find the tag that was defined for it and return the tag name.
5065    Otherwise return 0.  However, the value can never be 0
5066    in the cases in which this is used.
5067
5068    C++: If NAME is non-zero, this is the new name to install.  This is
5069    done when replacing anonymous tags with real tag names.  */
5070
5071 static tree
5072 lookup_tag_reverse (type, name)
5073      tree type;
5074      tree name;
5075 {
5076   register struct binding_level *level;
5077
5078   for (level = current_binding_level; level; level = level->level_chain)
5079     {
5080       register tree tail;
5081       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5082         {
5083           if (TREE_VALUE (tail) == type)
5084             {
5085               if (name)
5086                 TREE_PURPOSE (tail) = name;
5087               return TREE_PURPOSE (tail);
5088             }
5089         }
5090     }
5091   return NULL_TREE;
5092 }
5093 \f
5094 /* Look up NAME in the NAMESPACE.  */
5095
5096 tree
5097 lookup_namespace_name (namespace, name)
5098      tree namespace, name;
5099 {
5100   tree val;
5101   tree template_id = NULL_TREE;
5102
5103   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5104
5105   if (TREE_CODE (name) == NAMESPACE_DECL)
5106     /* This happens for A::B<int> when B is a namespace. */
5107     return name;
5108   else if (TREE_CODE (name) == TEMPLATE_DECL)
5109     {
5110       /* This happens for A::B where B is a template, and there are no
5111          template arguments.  */
5112       cp_error ("invalid use of `%D'", name);
5113       return error_mark_node;
5114     }
5115
5116   namespace = ORIGINAL_NAMESPACE (namespace);
5117
5118   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5119     {
5120       template_id = name;
5121       name = TREE_OPERAND (name, 0);
5122       if (TREE_CODE (name) == OVERLOAD)
5123         name = DECL_NAME (OVL_CURRENT (name));
5124       else if (TREE_CODE_CLASS (TREE_CODE (name)) == 'd')
5125         name = DECL_NAME (name);
5126     }
5127
5128   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5129
5130   val = make_node (CPLUS_BINDING);
5131   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5132     return error_mark_node;
5133
5134   if (BINDING_VALUE (val))
5135     {
5136       val = BINDING_VALUE (val);
5137
5138       if (template_id)
5139         {
5140           if (DECL_CLASS_TEMPLATE_P (val))
5141             val = lookup_template_class (val,
5142                                          TREE_OPERAND (template_id, 1),
5143                                          /*in_decl=*/NULL_TREE,
5144                                          /*context=*/NULL_TREE,
5145                                          /*entering_scope=*/0);
5146           else if (DECL_FUNCTION_TEMPLATE_P (val)
5147                    || TREE_CODE (val) == OVERLOAD)
5148             val = lookup_template_function (val,
5149                                             TREE_OPERAND (template_id, 1));
5150           else
5151             {
5152               cp_error ("`%D::%D' is not a template",
5153                         namespace, name);
5154               return error_mark_node;
5155             }
5156         }
5157
5158       /* If we have a single function from a using decl, pull it out.  */
5159       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5160         val = OVL_FUNCTION (val);
5161       return val;
5162     }
5163
5164   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5165   return error_mark_node;
5166 }
5167
5168 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5169
5170 static unsigned long
5171 typename_hash (k)
5172      hash_table_key k;
5173 {
5174   unsigned long hash;
5175   tree t;
5176
5177   t = (tree) k;
5178   hash = (((unsigned long) TYPE_CONTEXT (t))
5179           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5180
5181   return hash;
5182 }
5183
5184 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5185
5186 static boolean
5187 typename_compare (k1, k2)
5188      hash_table_key k1;
5189      hash_table_key k2;
5190 {
5191   tree t1;
5192   tree t2;
5193   tree d1;
5194   tree d2;
5195
5196   t1 = (tree) k1;
5197   t2 = (tree) k2;
5198   d1 = TYPE_NAME (t1);
5199   d2 = TYPE_NAME (t2);
5200
5201   return (DECL_NAME (d1) == DECL_NAME (d2)
5202           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5203           && ((TREE_TYPE (t1) != NULL_TREE)
5204               == (TREE_TYPE (t2) != NULL_TREE))
5205           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5206           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5207 }
5208
5209 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5210    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5211    is non-NULL, this type is being created by the implicit typename
5212    extension, and BASE_TYPE is a type named `t' in some base class of
5213    `T' which depends on template parameters.
5214
5215    Returns the new TYPENAME_TYPE.  */
5216
5217 tree
5218 build_typename_type (context, name, fullname, base_type)
5219      tree context;
5220      tree name;
5221      tree fullname;
5222      tree base_type;
5223 {
5224   tree t;
5225   tree d;
5226   struct hash_entry* e;
5227
5228   static struct hash_table ht;
5229
5230   if (!ht.table)
5231     {
5232       static struct hash_table *h = &ht;
5233       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5234                             &typename_compare))
5235         fatal ("virtual memory exhausted");
5236       ggc_add_tree_hash_table_root (&h, 1);
5237     }
5238
5239   /* Build the TYPENAME_TYPE.  */
5240   t = make_aggr_type (TYPENAME_TYPE);
5241   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5242   TYPENAME_TYPE_FULLNAME (t) = fullname;
5243   TREE_TYPE (t) = base_type;
5244
5245   /* Build the corresponding TYPE_DECL.  */
5246   d = build_decl (TYPE_DECL, name, t);
5247   TYPE_NAME (TREE_TYPE (d)) = d;
5248   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5249   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5250   DECL_ARTIFICIAL (d) = 1;
5251
5252   /* See if we already have this type.  */
5253   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5254   if (e)
5255     t = (tree) e->key;
5256   else
5257     /* Insert the type into the table.  */
5258     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5259
5260   return t;
5261 }
5262
5263 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5264    unless an error occurs, in which case error_mark_node is returned.
5265    If COMPLAIN zero, don't complain about any errors that occur.  */
5266
5267 tree
5268 make_typename_type (context, name, complain)
5269      tree context, name;
5270      int complain;
5271 {
5272   tree fullname;
5273
5274   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
5275     {
5276       if (!(TYPE_LANG_SPECIFIC (name)
5277             && (CLASSTYPE_IS_TEMPLATE (name)
5278                 || CLASSTYPE_USE_TEMPLATE (name))))
5279         name = TYPE_IDENTIFIER (name);
5280       else
5281         /* Create a TEMPLATE_ID_EXPR for the type.  */
5282         name = build_nt (TEMPLATE_ID_EXPR,
5283                          CLASSTYPE_TI_TEMPLATE (name),
5284                          CLASSTYPE_TI_ARGS (name));
5285     }
5286   else if (TREE_CODE (name) == TYPE_DECL)
5287     name = DECL_NAME (name);
5288
5289   fullname = name;
5290
5291   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5292     {
5293       name = TREE_OPERAND (name, 0);
5294       if (TREE_CODE (name) == TEMPLATE_DECL)
5295         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5296     }
5297   if (TREE_CODE (name) != IDENTIFIER_NODE)
5298     my_friendly_abort (2000);
5299
5300   if (TREE_CODE (context) == NAMESPACE_DECL)
5301     {
5302       /* We can get here from typename_sub0 in the explicit_template_type
5303          expansion.  Just fail.  */
5304       if (complain)
5305         cp_error ("no class template named `%#T' in `%#T'",
5306                   name, context);
5307       return error_mark_node;
5308     }
5309
5310   if (! uses_template_parms (context)
5311       || currently_open_class (context))
5312     {
5313       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5314         {
5315           tree tmpl = NULL_TREE;
5316           if (IS_AGGR_TYPE (context))
5317             tmpl = lookup_field (context, name, 0, 0);
5318           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5319             {
5320               if (complain)
5321                 cp_error ("no class template named `%#T' in `%#T'",
5322                           name, context);
5323               return error_mark_node;
5324             }
5325
5326           return lookup_template_class (tmpl,
5327                                         TREE_OPERAND (fullname, 1),
5328                                         NULL_TREE, context,
5329                                         /*entering_scope=*/0);
5330         }
5331       else
5332         {
5333           tree t;
5334
5335           if (!IS_AGGR_TYPE (context))
5336             {
5337               if (complain)
5338                 cp_error ("no type named `%#T' in `%#T'", name, context);
5339               return error_mark_node;
5340             }
5341
5342           t = lookup_field (context, name, 0, 1);
5343           if (t)
5344             return TREE_TYPE (t);
5345         }
5346     }
5347
5348   /* If the CONTEXT is not a template type, then either the field is
5349      there now or its never going to be.  */
5350   if (!uses_template_parms (context))
5351     {
5352       if (complain)
5353         cp_error ("no type named `%#T' in `%#T'", name, context);
5354       return error_mark_node;
5355     }
5356
5357
5358   return build_typename_type (context, name, fullname,  NULL_TREE);
5359 }
5360
5361 /* Select the right _DECL from multiple choices. */
5362
5363 static tree
5364 select_decl (binding, flags)
5365      tree binding;
5366      int flags;
5367 {
5368   tree val;
5369   val = BINDING_VALUE (binding);
5370   if (LOOKUP_NAMESPACES_ONLY (flags))
5371     {
5372       /* We are not interested in types. */
5373       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5374         return val;
5375       return NULL_TREE;
5376     }
5377
5378   /* If we could have a type and
5379      we have nothing or we need a type and have none.  */
5380   if (BINDING_TYPE (binding)
5381       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5382                    && TREE_CODE (val) != TYPE_DECL)))
5383     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5384   /* Don't return non-types if we really prefer types. */
5385   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5386            && (TREE_CODE (val) != TEMPLATE_DECL
5387                || !DECL_CLASS_TEMPLATE_P (val)))
5388     val = NULL_TREE;
5389
5390   return val;
5391 }
5392
5393 /* Unscoped lookup of a global: iterate over current namespaces,
5394    considering using-directives.  If SPACESP is non-NULL, store a list
5395    of the namespaces we've considered in it.  */
5396
5397 tree
5398 unqualified_namespace_lookup (name, flags, spacesp)
5399      tree name;
5400      int flags;
5401      tree *spacesp;
5402 {
5403   tree b = make_node (CPLUS_BINDING);
5404   tree initial = current_decl_namespace();
5405   tree scope = initial;
5406   tree siter;
5407   struct binding_level *level;
5408   tree val = NULL_TREE;
5409
5410   if (spacesp)
5411     *spacesp = NULL_TREE;
5412
5413   for (; !val; scope = CP_DECL_CONTEXT (scope))
5414     {
5415       if (spacesp)
5416         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5417       val = binding_for_name (name, scope);
5418
5419       /* Initialize binding for this context. */
5420       BINDING_VALUE (b) = BINDING_VALUE (val);
5421       BINDING_TYPE (b) = BINDING_TYPE (val);
5422
5423       /* Add all _DECLs seen through local using-directives. */
5424       for (level = current_binding_level;
5425            !level->namespace_p;
5426            level = level->level_chain)
5427         if (!lookup_using_namespace (name, b, level->using_directives,
5428                                      scope, flags, spacesp))
5429           /* Give up because of error. */
5430           return error_mark_node;
5431
5432       /* Add all _DECLs seen through global using-directives. */
5433       /* XXX local and global using lists should work equally. */
5434       siter = initial;
5435       while (1)
5436         {
5437           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5438                                        scope, flags, spacesp))
5439             /* Give up because of error. */
5440             return error_mark_node;
5441           if (siter == scope) break;
5442           siter = CP_DECL_CONTEXT (siter);
5443         }
5444
5445       val = select_decl (b, flags);
5446       if (scope == global_namespace)
5447         break;
5448     }
5449   return val;
5450 }
5451
5452 /* Combine prefer_type and namespaces_only into flags.  */
5453
5454 static int
5455 lookup_flags (prefer_type, namespaces_only)
5456   int prefer_type, namespaces_only;
5457 {
5458   if (namespaces_only)
5459     return LOOKUP_PREFER_NAMESPACES;
5460   if (prefer_type > 1)
5461     return LOOKUP_PREFER_TYPES;
5462   if (prefer_type > 0)
5463     return LOOKUP_PREFER_BOTH;
5464   return 0;
5465 }
5466
5467 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5468    ignore it or not.  Subroutine of lookup_name_real.  */
5469
5470 static tree
5471 qualify_lookup (val, flags)
5472      tree val;
5473      int flags;
5474 {
5475   if (val == NULL_TREE)
5476     return val;
5477   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5478     return val;
5479   if ((flags & LOOKUP_PREFER_TYPES)
5480       && (TREE_CODE (val) == TYPE_DECL
5481           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5482               && DECL_CLASS_TEMPLATE_P (val))))
5483     return val;
5484   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5485     return NULL_TREE;
5486   return val;
5487 }
5488
5489 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5490    that.  */
5491
5492 static void
5493 warn_about_implicit_typename_lookup (typename, binding)
5494      tree typename;
5495      tree binding;
5496 {
5497   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5498   tree name = DECL_NAME (typename);
5499
5500   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5501          && CLASSTYPE_TEMPLATE_INFO (subtype)
5502          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5503       && ! (TREE_CODE (binding) == TYPE_DECL
5504             && same_type_p (TREE_TYPE (binding), subtype)))
5505     {
5506       cp_warning ("lookup of `%D' finds `%#D'",
5507                   name, binding);
5508       cp_warning ("  instead of `%D' from dependent base class",
5509                   typename);
5510       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5511                   constructor_name (current_class_type), name);
5512     }
5513 }
5514
5515 /* Look up NAME in the current binding level and its superiors in the
5516    namespace of variables, functions and typedefs.  Return a ..._DECL
5517    node of some kind representing its definition if there is only one
5518    such declaration, or return a TREE_LIST with all the overloaded
5519    definitions if there are many, or return 0 if it is undefined.
5520
5521    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5522    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5523    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5524    Otherwise we prefer non-TYPE_DECLs.
5525
5526    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5527    using IDENTIFIER_CLASS_VALUE.  */
5528
5529 static tree
5530 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5531      tree name;
5532      int prefer_type, nonclass, namespaces_only;
5533 {
5534   tree t;
5535   tree val = NULL_TREE;
5536   int yylex = 0;
5537   tree from_obj = NULL_TREE;
5538   int flags;
5539   int val_is_implicit_typename = 0;
5540
5541   /* Hack: copy flag set by parser, if set. */
5542   if (only_namespace_names)
5543     namespaces_only = 1;
5544
5545   if (prefer_type == -2)
5546     {
5547       extern int looking_for_typename;
5548       tree type = NULL_TREE;
5549
5550       yylex = 1;
5551       prefer_type = looking_for_typename;
5552
5553       flags = lookup_flags (prefer_type, namespaces_only);
5554       /* If the next thing is '<', class templates are types. */
5555       if (looking_for_template)
5556         flags |= LOOKUP_TEMPLATES_EXPECTED;
5557
5558       /* std:: becomes :: for now.  */
5559       if (got_scope == std_node)
5560         got_scope = void_type_node;
5561
5562       if (got_scope)
5563         type = got_scope;
5564       else if (got_object != error_mark_node)
5565         type = got_object;
5566
5567       if (type)
5568         {
5569           if (type == error_mark_node)
5570             return error_mark_node;
5571           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5572             type = TREE_TYPE (type);
5573
5574           if (TYPE_P (type))
5575             type = complete_type (type);
5576
5577           if (TREE_CODE (type) == VOID_TYPE)
5578             type = global_namespace;
5579           if (TREE_CODE (type) == NAMESPACE_DECL)
5580             {
5581               val = make_node (CPLUS_BINDING);
5582               flags |= LOOKUP_COMPLAIN;
5583               if (!qualified_lookup_using_namespace (name, type, val, flags))
5584                 return NULL_TREE;
5585               val = select_decl (val, flags);
5586             }
5587           else if (! IS_AGGR_TYPE (type)
5588                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5589                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5590                    || TREE_CODE (type) == TYPENAME_TYPE)
5591             /* Someone else will give an error about this if needed.  */
5592             val = NULL_TREE;
5593           else if (type == current_class_type)
5594             val = IDENTIFIER_CLASS_VALUE (name);
5595           else
5596             {
5597               val = lookup_member (type, name, 0, prefer_type);
5598               type_access_control (type, val);
5599             }
5600         }
5601       else
5602         val = NULL_TREE;
5603
5604       if (got_scope)
5605         goto done;
5606       else if (got_object && val)
5607         from_obj = val;
5608     }
5609   else
5610     {
5611       flags = lookup_flags (prefer_type, namespaces_only);
5612       /* If we're not parsing, we need to complain. */
5613       flags |= LOOKUP_COMPLAIN;
5614     }
5615
5616   /* First, look in non-namespace scopes.  */
5617
5618   if (current_class_type == NULL_TREE)
5619     nonclass = 1;
5620
5621   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5622     {
5623       tree binding;
5624
5625       if (!LOCAL_BINDING_P (t) && nonclass)
5626         /* We're not looking for class-scoped bindings, so keep going.  */
5627         continue;
5628
5629       /* If this is the kind of thing we're looking for, we're done.  */
5630       if (qualify_lookup (BINDING_VALUE (t), flags))
5631         binding = BINDING_VALUE (t);
5632       else if ((flags & LOOKUP_PREFER_TYPES)
5633                && qualify_lookup (BINDING_TYPE (t), flags))
5634         binding = BINDING_TYPE (t);
5635       else
5636         binding = NULL_TREE;
5637
5638       /* Handle access control on types from enclosing or base classes.  */
5639       if (binding && ! yylex
5640           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5641         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5642
5643       if (binding
5644           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5645         {
5646           if (val_is_implicit_typename && !yylex)
5647             warn_about_implicit_typename_lookup (val, binding);
5648           val = binding;
5649           val_is_implicit_typename
5650             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5651           if (!val_is_implicit_typename)
5652             break;
5653         }
5654     }
5655
5656   /* Now lookup in namespace scopes.  */
5657   if (!val || val_is_implicit_typename)
5658     {
5659       t = unqualified_namespace_lookup (name, flags, 0);
5660       if (t)
5661         {
5662           if (val_is_implicit_typename && !yylex)
5663             warn_about_implicit_typename_lookup (val, t);
5664           val = t;
5665         }
5666     }
5667
5668  done:
5669   if (val)
5670     {
5671       /* This should only warn about types used in qualified-ids.  */
5672       if (from_obj && from_obj != val)
5673         {
5674           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5675               && TREE_CODE (val) == TYPE_DECL
5676               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5677             {
5678               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5679                           name, got_object, TREE_TYPE (from_obj));
5680               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5681                           TREE_TYPE (val));
5682             }
5683
5684           /* We don't change val to from_obj if got_object depends on
5685              template parms because that breaks implicit typename for
5686              destructor calls.  */
5687           if (! uses_template_parms (got_object))
5688             val = from_obj;
5689         }
5690
5691       /* If we have a single function from a using decl, pull it out.  */
5692       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5693         val = OVL_FUNCTION (val);
5694     }
5695   else if (from_obj)
5696     val = from_obj;
5697
5698   return val;
5699 }
5700
5701 tree
5702 lookup_name_nonclass (name)
5703      tree name;
5704 {
5705   return lookup_name_real (name, 0, 1, 0);
5706 }
5707
5708 tree
5709 lookup_function_nonclass (name, args)
5710      tree name;
5711      tree args;
5712 {
5713   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5714 }
5715
5716 tree
5717 lookup_name_namespace_only (name)
5718      tree name;
5719 {
5720   /* type-or-namespace, nonclass, namespace_only */
5721   return lookup_name_real (name, 1, 1, 1);
5722 }
5723
5724 tree
5725 lookup_name (name, prefer_type)
5726      tree name;
5727      int prefer_type;
5728 {
5729   return lookup_name_real (name, prefer_type, 0, 0);
5730 }
5731
5732 /* Similar to `lookup_name' but look only in the innermost non-class
5733    binding level.  */
5734
5735 tree
5736 lookup_name_current_level (name)
5737      tree name;
5738 {
5739   struct binding_level *b;
5740   tree t = NULL_TREE;
5741
5742   b = current_binding_level;
5743   while (b->parm_flag == 2)
5744     b = b->level_chain;
5745
5746   if (b->namespace_p)
5747     {
5748       t = IDENTIFIER_NAMESPACE_VALUE (name);
5749
5750       /* extern "C" function() */
5751       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5752         t = TREE_VALUE (t);
5753     }
5754   else if (IDENTIFIER_BINDING (name)
5755            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
5756     {
5757       while (1)
5758         {
5759           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
5760             return IDENTIFIER_VALUE (name);
5761
5762           if (b->keep == 2)
5763             b = b->level_chain;
5764           else
5765             break;
5766         }
5767     }
5768
5769   return t;
5770 }
5771
5772 /* Like lookup_name_current_level, but for types.  */
5773
5774 tree
5775 lookup_type_current_level (name)
5776      tree name;
5777 {
5778   register tree t = NULL_TREE;
5779
5780   my_friendly_assert (! current_binding_level->namespace_p, 980716);
5781
5782   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5783       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5784     {
5785       struct binding_level *b = current_binding_level;
5786       while (1)
5787         {
5788           if (purpose_member (name, b->type_shadowed))
5789             return REAL_IDENTIFIER_TYPE_VALUE (name);
5790           if (b->keep == 2)
5791             b = b->level_chain;
5792           else
5793             break;
5794         }
5795     }
5796
5797   return t;
5798 }
5799
5800 void
5801 begin_only_namespace_names ()
5802 {
5803   only_namespace_names = 1;
5804 }
5805
5806 void
5807 end_only_namespace_names ()
5808 {
5809   only_namespace_names = 0;
5810 }
5811 \f
5812 /* Arrange for the user to get a source line number, even when the
5813    compiler is going down in flames, so that she at least has a
5814    chance of working around problems in the compiler.  We used to
5815    call error(), but that let the segmentation fault continue
5816    through; now, it's much more passive by asking them to send the
5817    maintainers mail about the problem.  */
5818
5819 static void
5820 signal_catch (sig)
5821      int sig ATTRIBUTE_UNUSED;
5822 {
5823   signal (SIGSEGV, SIG_DFL);
5824 #ifdef SIGIOT
5825   signal (SIGIOT, SIG_DFL);
5826 #endif
5827 #ifdef SIGILL
5828   signal (SIGILL, SIG_DFL);
5829 #endif
5830 #ifdef SIGABRT
5831   signal (SIGABRT, SIG_DFL);
5832 #endif
5833 #ifdef SIGBUS
5834   signal (SIGBUS, SIG_DFL);
5835 #endif
5836   my_friendly_abort (0);
5837 }
5838
5839 /* Push the declarations of builtin types into the namespace.
5840    RID_INDEX, if < RID_MAX is the index of the builtin type
5841    in the array RID_POINTERS.  NAME is the name used when looking
5842    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
5843
5844 static void
5845 record_builtin_type (rid_index, name, type)
5846      enum rid rid_index;
5847      const char *name;
5848      tree type;
5849 {
5850   tree rname = NULL_TREE, tname = NULL_TREE;
5851   tree tdecl = NULL_TREE;
5852
5853   if ((int) rid_index < (int) RID_MAX)
5854     rname = ridpointers[(int) rid_index];
5855   if (name)
5856     tname = get_identifier (name);
5857
5858   TYPE_BUILT_IN (type) = 1;
5859
5860   if (tname)
5861     {
5862       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5863       set_identifier_type_value (tname, NULL_TREE);
5864       if ((int) rid_index < (int) RID_MAX)
5865         /* Built-in types live in the global namespace. */
5866         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5867     }
5868   if (rname != NULL_TREE)
5869     {
5870       if (tname != NULL_TREE)
5871         {
5872           set_identifier_type_value (rname, NULL_TREE);
5873           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5874         }
5875       else
5876         {
5877           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5878           set_identifier_type_value (rname, NULL_TREE);
5879         }
5880     }
5881 }
5882
5883 /* Record one of the standard Java types.
5884  * Declare it as having the given NAME.
5885  * If SIZE > 0, it is the size of one of the integral types;
5886  * otherwise it is the negative of the size of one of the other types.  */
5887
5888 static tree
5889 record_builtin_java_type (name, size)
5890      const char *name;
5891      int size;
5892 {
5893   tree type, decl;
5894   if (size > 0)
5895     type = make_signed_type (size);
5896   else if (size > -32)
5897     { /* "__java_char" or ""__java_boolean". */
5898       type = make_unsigned_type (-size);
5899       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5900     }
5901   else
5902     { /* "__java_float" or ""__java_double". */
5903       type = make_node (REAL_TYPE);
5904       TYPE_PRECISION (type) = - size;
5905       layout_type (type);
5906     }
5907   record_builtin_type (RID_MAX, name, type);
5908   decl = TYPE_NAME (type);
5909
5910   /* Suppress generate debug symbol entries for these types,
5911      since for normal C++ they are just clutter.
5912      However, push_lang_context undoes this if extern "Java" is seen. */
5913   DECL_IGNORED_P (decl) = 1;
5914
5915   TYPE_FOR_JAVA (type) = 1;
5916   return type;
5917 }
5918
5919 /* Push a type into the namespace so that the back-ends ignore it. */
5920
5921 static void
5922 record_unknown_type (type, name)
5923      tree type;
5924      const char *name;
5925 {
5926   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
5927   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
5928   DECL_IGNORED_P (decl) = 1;
5929   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5930   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
5931   TYPE_ALIGN (type) = 1;
5932   TYPE_MODE (type) = TYPE_MODE (void_type_node);
5933 }
5934
5935 /* Push overloaded decl, in global scope, with one argument so it
5936    can be used as a callback from define_function.  */
5937
5938 static void
5939 push_overloaded_decl_1 (x)
5940      tree x;
5941 {
5942   pushdecl (x);
5943 }
5944
5945 inline tree
5946 auto_function (name, type)
5947      tree name, type;
5948 {
5949   return define_function
5950     (IDENTIFIER_POINTER (name), type, push_overloaded_decl_1,
5951      IDENTIFIER_POINTER (build_decl_overload (name, TYPE_ARG_TYPES (type),
5952                                               0)));
5953 }
5954
5955 /* Create the predefined scalar types of C,
5956    and some nodes representing standard constants (0, 1, (void *)0).
5957    Initialize the global binding level.
5958    Make definitions for built-in primitive functions.  */
5959
5960 void
5961 init_decl_processing ()
5962 {
5963   tree fields[20];
5964   int wchar_type_size;
5965   tree array_domain_type;
5966
5967   /* Check to see that the user did not specify an invalid combination
5968      of command-line options.  */
5969   if (flag_new_abi && !flag_vtable_thunks)
5970     fatal ("the new ABI requires vtable thunks");
5971
5972   /* Have to make these distinct before we try using them.  */
5973   lang_name_cplusplus = get_identifier ("C++");
5974   lang_name_c = get_identifier ("C");
5975   lang_name_java = get_identifier ("Java");
5976
5977   /* Let the back-end now how to save and restore language-specific
5978      per-function globals.  */
5979   init_lang_status = &push_cp_function_context;
5980   free_lang_status = &pop_cp_function_context;
5981   mark_lang_status = &mark_cp_function_context;
5982
5983   cp_parse_init ();
5984   init_decl2 ();
5985   init_pt ();
5986
5987   /* Create the global variables.  */
5988   push_to_top_level ();
5989
5990   /* Enter the global namespace. */
5991   my_friendly_assert (global_namespace == NULL_TREE, 375);
5992   push_namespace (get_identifier ("::"));
5993   global_namespace = current_namespace;
5994   current_lang_name = NULL_TREE;
5995
5996   /* Adjust various flags based on command-line settings.  */
5997   if (flag_strict_prototype == 2)
5998     flag_strict_prototype = pedantic;
5999   if (! flag_permissive && ! pedantic)
6000     flag_pedantic_errors = 1;
6001   if (!flag_no_inline)
6002     flag_inline_trees = 1;
6003
6004   strict_prototypes_lang_c = flag_strict_prototype;
6005
6006   /* Initially, C.  */
6007   current_lang_name = lang_name_c;
6008
6009   current_function_decl = NULL_TREE;
6010   current_binding_level = NULL_BINDING_LEVEL;
6011   free_binding_level = NULL_BINDING_LEVEL;
6012
6013   /* Because most segmentation signals can be traced back into user
6014      code, catch them and at least give the user a chance of working
6015      around compiler bugs.  */
6016   signal (SIGSEGV, signal_catch);
6017
6018   /* We will also catch aborts in the back-end through signal_catch and
6019      give the user a chance to see where the error might be, and to defeat
6020      aborts in the back-end when there have been errors previously in their
6021      code.  */
6022 #ifdef SIGIOT
6023   signal (SIGIOT, signal_catch);
6024 #endif
6025 #ifdef SIGILL
6026   signal (SIGILL, signal_catch);
6027 #endif
6028 #ifdef SIGABRT
6029   signal (SIGABRT, signal_catch);
6030 #endif
6031 #ifdef SIGBUS
6032   signal (SIGBUS, signal_catch);
6033 #endif
6034
6035   build_common_tree_nodes (flag_signed_char);
6036
6037   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6038   TREE_TYPE (error_mark_list) = error_mark_node;
6039
6040   /* Make the binding_level structure for global names.  */
6041   pushlevel (0);
6042   global_binding_level = current_binding_level;
6043   /* The global level is the namespace level of ::.  */
6044   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6045   declare_namespace_level ();
6046
6047   this_identifier = get_identifier (THIS_NAME);
6048   in_charge_identifier = get_identifier (IN_CHARGE_NAME);
6049   ctor_identifier = get_identifier (CTOR_NAME);
6050   dtor_identifier = get_identifier (DTOR_NAME);
6051   pfn_identifier = get_identifier (VTABLE_PFN_NAME);
6052   index_identifier = get_identifier (VTABLE_INDEX_NAME);
6053   delta_identifier = get_identifier (VTABLE_DELTA_NAME);
6054   delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
6055   pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
6056
6057   /* Define `int' and `char' first so that dbx will output them first.  */
6058   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6059   record_builtin_type (RID_CHAR, "char", char_type_node);
6060
6061   /* `signed' is the same as `int' */
6062   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6063   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6064   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6065   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6066   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6067   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6068   record_builtin_type (RID_MAX, "long long unsigned int",
6069                        long_long_unsigned_type_node);
6070   record_builtin_type (RID_MAX, "long long unsigned",
6071                        long_long_unsigned_type_node);
6072   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6073   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6074   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6075
6076   ptrdiff_type_node
6077     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6078
6079   /* Define both `signed char' and `unsigned char'.  */
6080   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6081   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6082
6083   /* `unsigned long' is the standard type for sizeof.
6084      Note that stddef.h uses `unsigned long',
6085      and this must agree, even if long and int are the same size.  */
6086   set_sizetype
6087     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6088
6089   /* Create the widest literal types. */
6090   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6091   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6092                         widest_integer_literal_type_node));
6093
6094   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6095   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6096                         widest_unsigned_literal_type_node));
6097
6098   /* These are types that type_for_size and type_for_mode use.  */
6099   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6100   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6101   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6102   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6103 #if HOST_BITS_PER_WIDE_INT >= 64
6104   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6105 #endif
6106   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6107   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6108   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6109   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6110 #if HOST_BITS_PER_WIDE_INT >= 64
6111   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6112 #endif
6113
6114   build_common_tree_nodes_2 (flag_short_double);
6115
6116   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6117   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6118   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6119   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6120   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6121   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6122   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6123   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6124
6125   integer_two_node = build_int_2 (2, 0);
6126   TREE_TYPE (integer_two_node) = integer_type_node;
6127   integer_three_node = build_int_2 (3, 0);
6128   TREE_TYPE (integer_three_node) = integer_type_node;
6129
6130   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6131   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6132   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6133   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6134   TYPE_PRECISION (boolean_type_node) = 1;
6135   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6136   boolean_false_node = build_int_2 (0, 0);
6137   TREE_TYPE (boolean_false_node) = boolean_type_node;
6138   boolean_true_node = build_int_2 (1, 0);
6139   TREE_TYPE (boolean_true_node) = boolean_type_node;
6140
6141   signed_size_zero_node = build_int_2 (0, 0);  record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6142   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6143   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6144
6145   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6146                         complex_integer_type_node));
6147   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6148                         complex_float_type_node));
6149   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6150                         complex_double_type_node));
6151   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6152                         complex_long_double_type_node));
6153
6154   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6155
6156   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6157   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6158   TREE_PARMLIST (void_list_node) = 1;
6159
6160   /* Used for expressions that do nothing, but are not errors.  */
6161   void_zero_node = build_int_2 (0, 0);
6162   TREE_TYPE (void_zero_node) = void_type_node;
6163
6164   string_type_node = build_pointer_type (char_type_node);
6165   const_string_type_node
6166     = build_pointer_type (build_qualified_type (char_type_node,
6167                                                 TYPE_QUAL_CONST));
6168   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6169 #if 0
6170   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6171 #endif
6172
6173   /* Make a type to be the domain of a few array types
6174      whose domains don't really matter.
6175      200 is small enough that it always fits in size_t
6176      and large enough that it can hold most function names for the
6177      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
6178   array_domain_type = build_index_type (build_int_2 (200, 0));
6179
6180   /* Make a type for arrays of characters.
6181      With luck nothing will ever really depend on the length of this
6182      array type.  */
6183   char_array_type_node
6184     = build_array_type (char_type_node, array_domain_type);
6185   /* Likewise for arrays of ints.  */
6186   int_array_type_node
6187     = build_array_type (integer_type_node, array_domain_type);
6188
6189   if (flag_new_abi)
6190     delta_type_node = ptrdiff_type_node;
6191   else if (flag_huge_objects)
6192     delta_type_node = long_integer_type_node;
6193   else
6194     delta_type_node = short_integer_type_node;
6195
6196   if (flag_new_abi)
6197     vtable_index_type = ptrdiff_type_node;
6198   else
6199     vtable_index_type = delta_type_node;
6200
6201   default_function_type
6202     = build_function_type (integer_type_node, NULL_TREE);
6203
6204   ptr_type_node = build_pointer_type (void_type_node);
6205   const_ptr_type_node
6206     = build_pointer_type (build_qualified_type (void_type_node,
6207                                                 TYPE_QUAL_CONST));
6208   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6209   lang_type_promotes_to = convert_type_from_ellipsis;
6210
6211   void_ftype_ptr
6212     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6213
6214   /* C++ extensions */
6215
6216   unknown_type_node = make_node (UNKNOWN_TYPE);
6217   record_unknown_type (unknown_type_node, "unknown type");
6218
6219   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6220   TREE_TYPE (unknown_type_node) = unknown_type_node;
6221
6222   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6223
6224   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6225      result.  */
6226   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6227   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6228
6229   /* This is special for C++ so functions can be overloaded.  */
6230   wchar_type_node = get_identifier (flag_short_wchar
6231                                     ? "short unsigned int"
6232                                     : WCHAR_TYPE);
6233   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6234   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6235   signed_wchar_type_node = make_signed_type (wchar_type_size);
6236   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6237   wchar_type_node
6238     = TREE_UNSIGNED (wchar_type_node)
6239       ? unsigned_wchar_type_node
6240       : signed_wchar_type_node;
6241   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6242
6243   /* Artificial declaration of wchar_t -- can be bashed */
6244   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6245                                 wchar_type_node);
6246   pushdecl (wchar_decl_node);
6247
6248   /* This is for wide string constants.  */
6249   wchar_array_type_node
6250     = build_array_type (wchar_type_node, array_domain_type);
6251
6252   if (flag_vtable_thunks)
6253     {
6254       /* Make sure we get a unique function type, so we can give
6255          its pointer type a name.  (This wins for gdb.) */
6256       tree vfunc_type = make_node (FUNCTION_TYPE);
6257       TREE_TYPE (vfunc_type) = integer_type_node;
6258       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6259       layout_type (vfunc_type);
6260
6261       vtable_entry_type = build_pointer_type (vfunc_type);
6262     }
6263   else
6264     {
6265       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6266       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
6267                                    delta_type_node);
6268       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
6269                                    delta_type_node);
6270       fields[2] = build_lang_decl (FIELD_DECL, pfn_identifier,
6271                                    ptr_type_node);
6272       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6273                            double_type_node);
6274
6275       /* Make this part of an invisible union.  */
6276       fields[3] = copy_node (fields[2]);
6277       TREE_TYPE (fields[3]) = delta_type_node;
6278       DECL_NAME (fields[3]) = delta2_identifier;
6279       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6280       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6281       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6282       TREE_UNSIGNED (fields[3]) = 0;
6283       TREE_CHAIN (fields[2]) = fields[3];
6284       vtable_entry_type = build_qualified_type (vtable_entry_type,
6285                                                 TYPE_QUAL_CONST);
6286     }
6287   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6288
6289   vtbl_type_node
6290     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6291   layout_type (vtbl_type_node);
6292   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6293   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6294   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6295   layout_type (vtbl_ptr_type_node);
6296   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6297
6298   std_node = build_decl (NAMESPACE_DECL,
6299                          get_identifier (flag_honor_std ? "fake std":"std"),
6300                          void_type_node);
6301   pushdecl (std_node);
6302
6303   global_type_node = make_node (LANG_TYPE);
6304   record_unknown_type (global_type_node, "global type");
6305
6306   /* Now, C++.  */
6307   current_lang_name = lang_name_cplusplus;
6308
6309   {
6310     tree bad_alloc_type_node, newtype, deltype;
6311     if (flag_honor_std)
6312       push_namespace (get_identifier ("std"));
6313     bad_alloc_type_node = xref_tag
6314       (class_type_node, get_identifier ("bad_alloc"), 1);
6315     if (flag_honor_std)
6316       pop_namespace ();
6317     newtype = build_exception_variant
6318       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6319     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6320     auto_function (ansi_opname[(int) NEW_EXPR], newtype);
6321     auto_function (ansi_opname[(int) VEC_NEW_EXPR], newtype);
6322     global_delete_fndecl = auto_function (ansi_opname[(int) DELETE_EXPR],
6323                                           deltype);
6324     auto_function (ansi_opname[(int) VEC_DELETE_EXPR], deltype);
6325   }
6326
6327   abort_fndecl
6328     = define_function ("__pure_virtual", void_ftype, 0, 0);
6329
6330   /* Perform other language dependent initializations.  */
6331   init_class_processing ();
6332   init_init_processing ();
6333   init_search_processing ();
6334   init_rtti_processing ();
6335
6336   if (flag_exceptions)
6337     init_exception_processing ();
6338   if (flag_no_inline)
6339     {
6340       flag_inline_functions = 0;
6341     }
6342
6343   if (! supports_one_only ())
6344     flag_weak = 0;
6345
6346   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6347   declare_function_name ();
6348
6349   /* Prepare to check format strings against argument lists.  */
6350   init_function_format_info ();
6351
6352   /* Show we use EH for cleanups.  */
6353   using_eh_for_cleanups ();
6354
6355   print_error_function = lang_print_error_function;
6356   lang_get_alias_set = &c_get_alias_set;
6357   valid_lang_attribute = cp_valid_lang_attribute;
6358
6359   /* Maintain consistency.  Perhaps we should just complain if they
6360      say -fwritable-strings?  */
6361   if (flag_writable_strings)
6362     flag_const_strings = 0;
6363
6364   /* Add GC roots for all of our global variables.  */
6365   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6366   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6367   ggc_add_tree_root (&integer_three_node, 1);
6368   ggc_add_tree_root (&integer_two_node, 1);
6369   ggc_add_tree_root (&signed_size_zero_node, 1);
6370   ggc_add_tree_root (&size_one_node, 1);
6371   ggc_add_tree_root (&size_zero_node, 1);
6372   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6373                 mark_binding_level);
6374   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6375   ggc_add_tree_root (&static_ctors, 1);
6376   ggc_add_tree_root (&static_dtors, 1);
6377   ggc_add_tree_root (&lastiddecl, 1);
6378
6379   ggc_add_tree_root (&last_function_parm_tags, 1);
6380   ggc_add_tree_root (&current_function_return_value, 1);
6381   ggc_add_tree_root (&current_function_parms, 1);
6382   ggc_add_tree_root (&current_function_parm_tags, 1);
6383   ggc_add_tree_root (&last_function_parms, 1);
6384   ggc_add_tree_root (&error_mark_list, 1);
6385
6386   ggc_add_tree_root (&global_namespace, 1);
6387   ggc_add_tree_root (&global_type_node, 1);
6388   ggc_add_tree_root (&anonymous_namespace_name, 1);
6389
6390   ggc_add_tree_root (&got_object, 1);
6391   ggc_add_tree_root (&got_scope, 1);
6392
6393   ggc_add_tree_root (&current_lang_name, 1);
6394   ggc_add_tree_root (&static_aggregates, 1);
6395 }
6396
6397 /* Function to print any language-specific context for an error message.  */
6398
6399 static void
6400 lang_print_error_function (file)
6401      const char *file;
6402 {
6403   default_print_error_function (file);
6404   maybe_print_template_context ();
6405 }
6406
6407 /* Make a definition for a builtin function named NAME and whose data type
6408    is TYPE.  TYPE should be a function type with argument types.
6409
6410    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6411    the name to be called if we can't opencode the function.  */
6412
6413 tree
6414 define_function (name, type, pfn, library_name)
6415      const char *name;
6416      tree type;
6417      void (*pfn) PARAMS ((tree));
6418      const char *library_name;
6419 {
6420   tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
6421   DECL_EXTERNAL (decl) = 1;
6422   TREE_PUBLIC (decl) = 1;
6423   DECL_ARTIFICIAL (decl) = 1;
6424
6425   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6426   DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6427
6428   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6429      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6430      function in the namespace.  */
6431   if (pfn) (*pfn) (decl);
6432   if (library_name)
6433     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
6434   make_function_rtl (decl);
6435   return decl;
6436 }
6437
6438
6439 /* Wrapper around define_function, for the benefit of
6440    c_common_nodes_and_builtins.
6441    FUNCTION_CODE tells later passes how to compile calls to this function.
6442    See tree.h for its possible values.  */
6443
6444 tree
6445 builtin_function (name, type, code, class, libname)
6446      const char *name;
6447      tree type;
6448      int code;
6449      enum built_in_class class;
6450      const char *libname;
6451 {
6452   tree decl = define_function (name, type, (void (*) PARAMS ((tree)))pushdecl,
6453                                libname);
6454   DECL_BUILT_IN_CLASS (decl) = class;
6455   DECL_FUNCTION_CODE (decl) = code;
6456   return decl;
6457 }
6458 \f
6459 /* When we call finish_struct for an anonymous union, we create
6460    default copy constructors and such.  But, an anonymous union
6461    shouldn't have such things; this function undoes the damage to the
6462    anonymous union type T.
6463
6464    (The reason that we create the synthesized methods is that we don't
6465    distinguish `union { int i; }' from `typedef union { int i; } U'.
6466    The first is an anonymous union; the second is just an ordinary
6467    union type.)  */
6468
6469 void
6470 fixup_anonymous_aggr (t)
6471      tree t;
6472 {
6473   tree *q;
6474
6475   /* Wipe out memory of synthesized methods */
6476   TYPE_HAS_CONSTRUCTOR (t) = 0;
6477   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6478   TYPE_HAS_INIT_REF (t) = 0;
6479   TYPE_HAS_CONST_INIT_REF (t) = 0;
6480   TYPE_HAS_ASSIGN_REF (t) = 0;
6481   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6482
6483   /* Splice the implicitly generated functions out of the TYPE_METHODS
6484      list.  */
6485   q = &TYPE_METHODS (t);
6486   while (*q)
6487     {
6488       if (DECL_ARTIFICIAL (*q))
6489         *q = TREE_CHAIN (*q);
6490       else
6491         q = &TREE_CHAIN (*q);
6492     }
6493
6494   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6495   if (TYPE_METHODS (t))
6496     error ("an anonymous union cannot have function members");
6497 }
6498
6499 /* Make sure that a declaration with no declarator is well-formed, i.e.
6500    just defines a tagged type or anonymous union.
6501
6502    Returns the type defined, if any.  */
6503
6504 tree
6505 check_tag_decl (declspecs)
6506      tree declspecs;
6507 {
6508   int found_type = 0;
6509   tree ob_modifier = NULL_TREE;
6510   register tree link;
6511   register tree t = NULL_TREE;
6512
6513   for (link = declspecs; link; link = TREE_CHAIN (link))
6514     {
6515       register tree value = TREE_VALUE (link);
6516
6517       if (TYPE_P (value))
6518         {
6519           ++found_type;
6520
6521           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6522             {
6523               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6524               t = value;
6525             }
6526         }
6527       else if (value == ridpointers[(int) RID_FRIEND])
6528         {
6529           if (current_class_type == NULL_TREE
6530               || current_scope () != current_class_type)
6531             ob_modifier = value;
6532         }
6533       else if (value == ridpointers[(int) RID_STATIC]
6534                || value == ridpointers[(int) RID_EXTERN]
6535                || value == ridpointers[(int) RID_AUTO]
6536                || value == ridpointers[(int) RID_REGISTER]
6537                || value == ridpointers[(int) RID_INLINE]
6538                || value == ridpointers[(int) RID_VIRTUAL]
6539                || value == ridpointers[(int) RID_CONST]
6540                || value == ridpointers[(int) RID_VOLATILE]
6541                || value == ridpointers[(int) RID_EXPLICIT])
6542         ob_modifier = value;
6543     }
6544
6545   if (found_type > 1)
6546     error ("multiple types in one declaration");
6547
6548   /* Inside a class, we might be in a friend or access declaration.
6549      Until we have a good way of detecting the latter, don't warn.  */
6550   if (t == NULL_TREE && ! current_class_type)
6551     pedwarn ("declaration does not declare anything");
6552
6553   /* Check for an anonymous union.  We're careful
6554      accessing TYPE_IDENTIFIER because some built-in types, like
6555      pointer-to-member types, do not have TYPE_NAME.  */
6556   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6557            && TYPE_NAME (t)
6558            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6559     {
6560       /* Anonymous unions are objects, so they can have specifiers.  */;
6561       SET_ANON_AGGR_TYPE_P (t);
6562
6563       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6564         pedwarn ("ISO C++ prohibits anonymous structs");
6565     }
6566
6567   else if (ob_modifier)
6568     {
6569       if (ob_modifier == ridpointers[(int) RID_INLINE]
6570           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6571         cp_error ("`%D' can only be specified for functions", ob_modifier);
6572       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6573         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6574       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6575         cp_error ("`%D' can only be specified for constructors",
6576                   ob_modifier);
6577       else
6578         cp_error ("`%D' can only be specified for objects and functions",
6579                   ob_modifier);
6580     }
6581
6582   return t;
6583 }
6584
6585 /* Called when a declaration is seen that contains no names to declare.
6586    If its type is a reference to a structure, union or enum inherited
6587    from a containing scope, shadow that tag name for the current scope
6588    with a forward reference.
6589    If its type defines a new named structure or union
6590    or defines an enum, it is valid but we need not do anything here.
6591    Otherwise, it is an error.
6592
6593    C++: may have to grok the declspecs to learn about static,
6594    complain for anonymous unions.  */
6595
6596 void
6597 shadow_tag (declspecs)
6598      tree declspecs;
6599 {
6600   tree t = check_tag_decl (declspecs);
6601
6602   if (t)
6603     maybe_process_partial_specialization (t);
6604
6605   /* This is where the variables in an anonymous union are
6606      declared.  An anonymous union declaration looks like:
6607      union { ... } ;
6608      because there is no declarator after the union, the parser
6609      sends that declaration here.  */
6610   if (t && ANON_AGGR_TYPE_P (t))
6611     {
6612       fixup_anonymous_aggr (t);
6613
6614       if (TYPE_FIELDS (t))
6615         {
6616           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6617                                       NULL_TREE);
6618           finish_anon_union (decl);
6619         }
6620     }
6621 }
6622 \f
6623 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6624
6625 tree
6626 groktypename (typename)
6627      tree typename;
6628 {
6629   if (TREE_CODE (typename) != TREE_LIST)
6630     return typename;
6631   return grokdeclarator (TREE_VALUE (typename),
6632                          TREE_PURPOSE (typename),
6633                          TYPENAME, 0, NULL_TREE);
6634 }
6635
6636 /* Decode a declarator in an ordinary declaration or data definition.
6637    This is called as soon as the type information and variable name
6638    have been parsed, before parsing the initializer if any.
6639    Here we create the ..._DECL node, fill in its type,
6640    and put it on the list of decls for the current context.
6641    The ..._DECL node is returned as the value.
6642
6643    Exception: for arrays where the length is not specified,
6644    the type is left null, to be filled in by `cp_finish_decl'.
6645
6646    Function definitions do not come here; they go to start_function
6647    instead.  However, external and forward declarations of functions
6648    do go through here.  Structure field declarations are done by
6649    grokfield and not through here.  */
6650
6651 /* Set this to zero to debug not using the temporary obstack
6652    to parse initializers.  */
6653 int debug_temp_inits = 1;
6654
6655 tree
6656 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6657      tree declarator, declspecs;
6658      int initialized;
6659      tree attributes, prefix_attributes;
6660 {
6661   register tree decl;
6662   register tree type, tem;
6663   tree context;
6664   extern int have_extern_spec;
6665   extern int used_extern_spec;
6666   tree attrlist;
6667
6668 #if 0
6669   /* See code below that used this.  */
6670   int init_written = initialized;
6671 #endif
6672
6673   /* This should only be done once on the top most decl.  */
6674   if (have_extern_spec && !used_extern_spec)
6675     {
6676       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6677                                   declspecs);
6678       used_extern_spec = 1;
6679     }
6680
6681   if (attributes || prefix_attributes)
6682     attrlist = build_tree_list (attributes, prefix_attributes);
6683   else
6684     attrlist = NULL_TREE;
6685
6686   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6687                          attrlist);
6688
6689   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6690     return NULL_TREE;
6691
6692   type = TREE_TYPE (decl);
6693
6694   if (type == error_mark_node)
6695     return NULL_TREE;
6696
6697   context = DECL_CONTEXT (decl);
6698
6699   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
6700       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
6701     {
6702       /* When parsing the initializer, lookup should use the object's
6703          namespace. */
6704       push_decl_namespace (context);
6705     }
6706
6707   /* We are only interested in class contexts, later. */
6708   if (context && TREE_CODE (context) == NAMESPACE_DECL)
6709     context = NULL_TREE;
6710
6711   if (initialized)
6712     /* Is it valid for this decl to have an initializer at all?
6713        If not, set INITIALIZED to zero, which will indirectly
6714        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6715     switch (TREE_CODE (decl))
6716       {
6717       case TYPE_DECL:
6718         /* typedef foo = bar  means give foo the same type as bar.
6719            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6720            Any other case of an initialization in a TYPE_DECL is an error.  */
6721         if (pedantic || list_length (declspecs) > 1)
6722           {
6723             cp_error ("typedef `%D' is initialized", decl);
6724             initialized = 0;
6725           }
6726         break;
6727
6728       case FUNCTION_DECL:
6729         cp_error ("function `%#D' is initialized like a variable", decl);
6730         initialized = 0;
6731         break;
6732
6733       default:
6734         break;
6735       }
6736
6737   if (initialized)
6738     {
6739       if (! toplevel_bindings_p ()
6740           && DECL_EXTERNAL (decl))
6741         cp_warning ("declaration of `%#D' has `extern' and is initialized",
6742                     decl);
6743       DECL_EXTERNAL (decl) = 0;
6744       if (toplevel_bindings_p ())
6745         TREE_STATIC (decl) = 1;
6746
6747       /* Tell `pushdecl' this is an initialized decl
6748          even though we don't yet have the initializer expression.
6749          Also tell `cp_finish_decl' it may store the real initializer.  */
6750       DECL_INITIAL (decl) = error_mark_node;
6751     }
6752
6753 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
6754   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
6755 #endif
6756
6757   /* Set attributes here so if duplicate decl, will have proper attributes.  */
6758   cplus_decl_attributes (decl, attributes, prefix_attributes);
6759
6760   if (context && TYPE_SIZE (complete_type (context)) != NULL_TREE)
6761     {
6762       push_nested_class (context, 2);
6763
6764       if (TREE_CODE (decl) == VAR_DECL)
6765         {
6766           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
6767           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
6768             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
6769           else
6770             {
6771               if (DECL_CONTEXT (field) != context)
6772                 {
6773                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
6774                               DECL_CONTEXT (field), DECL_NAME (decl),
6775                               context, DECL_NAME (decl));
6776                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
6777                 }
6778               /* Static data member are tricky; an in-class initialization
6779                  still doesn't provide a definition, so the in-class
6780                  declaration will have DECL_EXTERNAL set, but will have an
6781                  initialization.  Thus, duplicate_decls won't warn
6782                  about this situation, and so we check here.  */
6783               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
6784                 cp_error ("duplicate initialization of %D", decl);
6785               if (duplicate_decls (decl, field))
6786                 decl = field;
6787             }
6788         }
6789       else
6790         {
6791           tree field = check_classfn (context, decl);
6792           if (field && duplicate_decls (decl, field))
6793             decl = field;
6794         }
6795
6796       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
6797       DECL_IN_AGGR_P (decl) = 0;
6798       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
6799           || CLASSTYPE_USE_TEMPLATE (context))
6800         {
6801           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
6802           /* [temp.expl.spec] An explicit specialization of a static data
6803              member of a template is a definition if the declaration
6804              includes an initializer; otherwise, it is a declaration.
6805
6806              We check for processing_specialization so this only applies
6807              to the new specialization syntax.  */
6808           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
6809             DECL_EXTERNAL (decl) = 1;
6810         }
6811
6812       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
6813         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6814                     decl);
6815     }
6816
6817   /* Enter this declaration into the symbol table.  */
6818   tem = maybe_push_decl (decl);
6819
6820   if (processing_template_decl)
6821     tem = push_template_decl (tem);
6822
6823 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6824   /* Tell the back-end to use or not use .common as appropriate.  If we say
6825      -fconserve-space, we want this to save .data space, at the expense of
6826      wrong semantics.  If we say -fno-conserve-space, we want this to
6827      produce errors about redefs; to do this we force variables into the
6828      data segment.  */
6829   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
6830 #endif
6831
6832   if (! processing_template_decl)
6833     start_decl_1 (tem);
6834
6835   return tem;
6836 }
6837
6838 void
6839 start_decl_1 (decl)
6840      tree decl;
6841 {
6842   tree type = TREE_TYPE (decl);
6843   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
6844
6845   if (type == error_mark_node)
6846     return;
6847
6848   /* If this type of object needs a cleanup, but we're not allowed to
6849      add any more objects with cleanups to the current scope, create a
6850      new binding level.  */
6851   if (TYPE_NEEDS_DESTRUCTOR (type)
6852       && current_binding_level->more_cleanups_ok == 0)
6853     {
6854       keep_next_level (2);
6855       pushlevel (1);
6856       clear_last_expr ();
6857       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
6858     }
6859
6860   if (initialized)
6861     /* Is it valid for this decl to have an initializer at all?
6862        If not, set INITIALIZED to zero, which will indirectly
6863        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6864     {
6865       /* Don't allow initializations for incomplete types except for
6866          arrays which might be completed by the initialization.  */
6867       if (TYPE_SIZE (complete_type (type)) != NULL_TREE)
6868         ;                       /* A complete type is ok.  */
6869       else if (TREE_CODE (type) != ARRAY_TYPE)
6870         {
6871           cp_error ("variable `%#D' has initializer but incomplete type",
6872                     decl);
6873           initialized = 0;
6874           type = TREE_TYPE (decl) = error_mark_node;
6875         }
6876       else if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
6877         {
6878           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
6879             cp_error ("elements of array `%#D' have incomplete type", decl);
6880           /* else we already gave an error in start_decl.  */
6881           initialized = 0;
6882         }
6883     }
6884
6885   if (!initialized
6886       && TREE_CODE (decl) != TYPE_DECL
6887       && TREE_CODE (decl) != TEMPLATE_DECL
6888       && type != error_mark_node
6889       && IS_AGGR_TYPE (type)
6890       && ! DECL_EXTERNAL (decl))
6891     {
6892       if ((! processing_template_decl || ! uses_template_parms (type))
6893           && TYPE_SIZE (complete_type (type)) == NULL_TREE)
6894         {
6895           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6896                  decl);
6897           /* Change the type so that assemble_variable will give
6898              DECL an rtl we can live with: (mem (const_int 0)).  */
6899           type = TREE_TYPE (decl) = error_mark_node;
6900         }
6901       else
6902         {
6903           /* If any base type in the hierarchy of TYPE needs a constructor,
6904              then we set initialized to 1.  This way any nodes which are
6905              created for the purposes of initializing this aggregate
6906              will live as long as it does.  This is necessary for global
6907              aggregates which do not have their initializers processed until
6908              the end of the file.  */
6909           initialized = TYPE_NEEDS_CONSTRUCTING (type);
6910         }
6911     }
6912
6913   if (! initialized)
6914     DECL_INITIAL (decl) = NULL_TREE;
6915 }
6916
6917 /* Handle initialization of references.
6918    These three arguments are from `cp_finish_decl', and have the
6919    same meaning here that they do there.
6920
6921    Quotes on semantics can be found in ARM 8.4.3.  */
6922
6923 static void
6924 grok_reference_init (decl, type, init)
6925      tree decl, type, init;
6926 {
6927   tree tmp;
6928
6929   if (init == NULL_TREE)
6930     {
6931       if ((DECL_LANG_SPECIFIC (decl) == 0
6932            || DECL_IN_AGGR_P (decl) == 0)
6933           && ! DECL_THIS_EXTERN (decl))
6934         cp_error ("`%D' declared as reference but not initialized", decl);
6935       return;
6936     }
6937
6938   if (init == error_mark_node)
6939     return;
6940
6941   if (TREE_CODE (init) == CONSTRUCTOR)
6942     {
6943       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
6944       return;
6945     }
6946
6947   if (TREE_CODE (init) == TREE_LIST)
6948     init = build_compound_expr (init);
6949
6950   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
6951     init = convert_from_reference (init);
6952
6953   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
6954       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
6955     {
6956       /* Note: default conversion is only called in very special cases.  */
6957       init = default_conversion (init);
6958     }
6959
6960   /* Convert INIT to the reference type TYPE.  This may involve the
6961      creation of a temporary, whose lifetime must be the same as that
6962      of the reference.  If so, a DECL_STMT for the temporary will be
6963      added just after the DECL_STMT for DECL.  That's why we don't set
6964      DECL_INITIAL for local references (instead assigning to them
6965      explicitly); we need to allow the temporary to be initialized
6966      first.  */
6967   tmp = convert_to_reference
6968     (type, init, CONV_IMPLICIT,
6969      LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
6970
6971   if (tmp == error_mark_node)
6972     return;
6973   else if (tmp != NULL_TREE)
6974     {
6975       init = tmp;
6976       tmp = save_expr (tmp);
6977       if (building_stmt_tree ())
6978         {
6979           /* Initialize the declaration.  */
6980           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
6981           finish_expr_stmt (tmp);
6982         }
6983       else
6984         DECL_INITIAL (decl) = tmp;
6985     }
6986   else
6987     {
6988       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
6989       return;
6990     }
6991
6992   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
6993     {
6994       expand_static_init (decl, DECL_INITIAL (decl));
6995       DECL_INITIAL (decl) = NULL_TREE;
6996     }
6997   return;
6998 }
6999
7000 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7001    mucking with forces it does not comprehend (i.e. initialization with a
7002    constructor).  If we are at global scope and won't go into COMMON, fill
7003    it in with a dummy CONSTRUCTOR to force the variable into .data;
7004    otherwise we can use error_mark_node.  */
7005
7006 static tree
7007 obscure_complex_init (decl, init)
7008      tree decl, init;
7009 {
7010   if (! flag_no_inline && TREE_STATIC (decl))
7011     {
7012       if (extract_init (decl, init))
7013         return NULL_TREE;
7014     }
7015
7016 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7017   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7018     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7019                                  NULL_TREE);
7020   else
7021 #endif
7022     DECL_INITIAL (decl) = error_mark_node;
7023
7024   return init;
7025 }
7026
7027 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7028    array until we finish parsing the initializer.  If that's the
7029    situation we're in, update DECL accordingly.  */
7030
7031 static void
7032 maybe_deduce_size_from_array_init (decl, init)
7033      tree decl;
7034      tree init;
7035 {
7036   tree type = TREE_TYPE (decl);
7037
7038   if (TREE_CODE (type) == ARRAY_TYPE
7039       && TYPE_DOMAIN (type) == NULL_TREE
7040       && TREE_CODE (decl) != TYPE_DECL)
7041     {
7042       int do_default
7043         = (TREE_STATIC (decl)
7044            /* Even if pedantic, an external linkage array
7045               may have incomplete type at first.  */
7046            ? pedantic && ! DECL_EXTERNAL (decl)
7047            : !DECL_EXTERNAL (decl));
7048       tree initializer = init ? init : DECL_INITIAL (decl);
7049       int failure = complete_array_type (type, initializer, do_default);
7050
7051       if (failure == 1)
7052         cp_error ("initializer fails to determine size of `%D'", decl);
7053
7054       if (failure == 2)
7055         {
7056           if (do_default)
7057             cp_error ("array size missing in `%D'", decl);
7058           /* If a `static' var's size isn't known, make it extern as
7059              well as static, so it does not get allocated.  If it's not
7060              `static', then don't mark it extern; finish_incomplete_decl
7061              will give it a default size and it will get allocated.  */
7062           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7063             DECL_EXTERNAL (decl) = 1;
7064         }
7065
7066       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7067           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7068                               integer_zero_node))
7069         cp_error ("zero-size array `%D'", decl);
7070
7071       layout_decl (decl, 0);
7072     }
7073 }
7074
7075 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7076    any appropriate error messages regarding the layout.  */
7077
7078 static void
7079 layout_var_decl (decl)
7080      tree decl;
7081 {
7082   tree type = TREE_TYPE (decl);
7083 #if 0
7084   tree ttype = target_type (type);
7085 #endif
7086
7087   /* If we haven't already layed out this declaration, do so now.
7088      Note that we must not call complete type for an external object
7089      because it's type might involve templates that we are not
7090      supposed to isntantiate yet.  (And it's perfectly legal to say
7091      `extern X x' for some incomplete type `X'.)  */
7092   if (!DECL_EXTERNAL (decl))
7093     complete_type (type);
7094   if (!DECL_SIZE (decl) && TYPE_SIZE (type))
7095     layout_decl (decl, 0);
7096
7097   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7098     {
7099       /* An automatic variable with an incomplete type: that is an error.
7100          Don't talk about array types here, since we took care of that
7101          message in grokdeclarator.  */
7102       cp_error ("storage size of `%D' isn't known", decl);
7103       TREE_TYPE (decl) = error_mark_node;
7104     }
7105 #if 0
7106   /* Keep this code around in case we later want to control debug info
7107      based on whether a type is "used".  (jason 1999-11-11) */
7108
7109   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7110     /* Let debugger know it should output info for this type.  */
7111     note_debug_info_needed (ttype);
7112
7113   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7114     note_debug_info_needed (DECL_CONTEXT (decl));
7115 #endif
7116
7117   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7118       && DECL_SIZE (decl) != NULL_TREE
7119       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7120     {
7121       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7122         constant_expression_warning (DECL_SIZE (decl));
7123       else
7124         cp_error ("storage size of `%D' isn't constant", decl);
7125     }
7126 }
7127
7128 /* If a local static variable is declared in an inline function, or if
7129    we have a weak definition, we must endeavor to create only one
7130    instance of the variable at link-time.  */
7131
7132 static void
7133 maybe_commonize_var (decl)
7134      tree decl;
7135 {
7136   /* Static data in a function with comdat linkage also has comdat
7137      linkage.  */
7138   if (TREE_STATIC (decl)
7139       /* Don't mess with __FUNCTION__.  */
7140       && ! TREE_ASM_WRITTEN (decl)
7141       && current_function_decl
7142       && DECL_CONTEXT (decl) == current_function_decl
7143       && (DECL_THIS_INLINE (current_function_decl)
7144           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7145       && TREE_PUBLIC (current_function_decl))
7146     {
7147       /* Rather than try to get this right with inlining, we suppress
7148          inlining of such functions.  */
7149       current_function_cannot_inline
7150         = "function with static variable cannot be inline";
7151
7152       /* If flag_weak, we don't need to mess with this, as we can just
7153          make the function weak, and let it refer to its unique local
7154          copy.  This works because we don't allow the function to be
7155          inlined.  */
7156       if (! flag_weak)
7157         {
7158           if (DECL_INTERFACE_KNOWN (current_function_decl))
7159             {
7160               TREE_PUBLIC (decl) = 1;
7161               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7162             }
7163           else if (DECL_INITIAL (decl) == NULL_TREE
7164                    || DECL_INITIAL (decl) == error_mark_node)
7165             {
7166               TREE_PUBLIC (decl) = 1;
7167               DECL_COMMON (decl) = 1;
7168             }
7169           /* else we lose. We can only do this if we can use common,
7170              which we can't if it has been initialized.  */
7171
7172           if (TREE_PUBLIC (decl))
7173             DECL_ASSEMBLER_NAME (decl)
7174               = build_static_name (current_function_decl, DECL_NAME (decl));
7175           else if (! DECL_ARTIFICIAL (decl))
7176             {
7177               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7178               cp_warning_at ("  you can work around this by removing the initializer", decl);
7179             }
7180         }
7181     }
7182   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7183     /* Set it up again; we might have set DECL_INITIAL since the last
7184        time.  */
7185     comdat_linkage (decl);
7186 }
7187
7188 /* Issue an error message if DECL is an uninitialized const variable.  */
7189
7190 static void
7191 check_for_uninitialized_const_var (decl)
7192      tree decl;
7193 {
7194   tree type = TREE_TYPE (decl);
7195
7196   /* ``Unless explicitly declared extern, a const object does not have
7197      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7198      7.1.6 */
7199   if (TREE_CODE (decl) == VAR_DECL
7200       && TREE_CODE (type) != REFERENCE_TYPE
7201       && CP_TYPE_CONST_P (type)
7202       && !TYPE_NEEDS_CONSTRUCTING (type)
7203       && !DECL_INITIAL (decl))
7204     cp_error ("uninitialized const `%D'", decl);
7205 }
7206
7207 /* Verify INIT (the initializer for DECL), and record the
7208    initialization in DECL_INITIAL, if appropriate.  Returns a new
7209    value for INIT.  */
7210
7211 static tree
7212 check_initializer (decl, init)
7213      tree decl;
7214      tree init;
7215 {
7216   tree type;
7217
7218   if (TREE_CODE (decl) == FIELD_DECL)
7219     return init;
7220
7221   type = TREE_TYPE (decl);
7222
7223   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7224   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7225     init = NULL_TREE;
7226
7227   /* Check the initializer.  */
7228   if (init)
7229     {
7230       /* Things that are going to be initialized need to have complete
7231          type.  */
7232       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7233
7234       if (type == error_mark_node)
7235         /* We will have already complained.  */
7236         init = NULL_TREE;
7237       else if (TYPE_SIZE (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7238         {
7239           cp_error ("variable-sized object `%D' may not be initialized", decl);
7240           init = NULL_TREE;
7241         }
7242       else if (TREE_CODE (type) == ARRAY_TYPE
7243                && !TYPE_SIZE (TREE_TYPE (type)))
7244         {
7245           cp_error ("elements of array `%#D' have incomplete type", decl);
7246           init = NULL_TREE;
7247         }
7248       else if (!TYPE_SIZE (type))
7249         {
7250           cp_error ("`%D' has incomplete type", decl);
7251           TREE_TYPE (decl) = error_mark_node;
7252           init = NULL_TREE;
7253         }
7254     }
7255
7256   if (TREE_CODE (decl) == CONST_DECL)
7257     {
7258       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7259
7260       DECL_INITIAL (decl) = init;
7261
7262       /* This will keep us from needing to worry about our obstacks.  */
7263       my_friendly_assert (init != NULL_TREE, 149);
7264       init = NULL_TREE;
7265     }
7266   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7267     {
7268       if (TREE_STATIC (decl))
7269         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7270       grok_reference_init (decl, type, init);
7271       init = NULL_TREE;
7272     }
7273   else if (init)
7274     {
7275       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7276         {
7277           if (TREE_CODE (type) == ARRAY_TYPE)
7278             init = digest_init (type, init, (tree *) 0);
7279           else if (TREE_CODE (init) == CONSTRUCTOR
7280                    && TREE_HAS_CONSTRUCTOR (init))
7281             {
7282               if (TYPE_NON_AGGREGATE_CLASS (type))
7283                 {
7284                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7285                             decl);
7286                   init = error_mark_node;
7287                 }
7288               else
7289                 goto dont_use_constructor;
7290             }
7291         }
7292       else
7293         {
7294         dont_use_constructor:
7295           if (TREE_CODE (init) != TREE_VEC)
7296             init = store_init_value (decl, init);
7297         }
7298
7299       if (init)
7300         /* We must hide the initializer so that expand_decl
7301            won't try to do something it does not understand.  */
7302         init = obscure_complex_init (decl, init);
7303     }
7304   else if (DECL_EXTERNAL (decl))
7305     ;
7306   else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
7307            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7308     {
7309       tree core_type = strip_array_types (type);
7310
7311       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7312         {
7313           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7314             cp_error ("structure `%D' with uninitialized const members", decl);
7315           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7316             cp_error ("structure `%D' with uninitialized reference members",
7317                       decl);
7318         }
7319
7320       check_for_uninitialized_const_var (decl);
7321
7322       if (TYPE_SIZE (type) != NULL_TREE
7323           && TYPE_NEEDS_CONSTRUCTING (type))
7324         init = obscure_complex_init (decl, NULL_TREE);
7325
7326     }
7327   else
7328     check_for_uninitialized_const_var (decl);
7329
7330   return init;
7331 }
7332
7333 /* If DECL is not a local variable, give it RTL.  */
7334
7335 static void
7336 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7337      tree decl;
7338      tree init;
7339      const char *asmspec;
7340 {
7341   int toplev;
7342   tree type;
7343
7344   type = TREE_TYPE (decl);
7345   toplev = toplevel_bindings_p ();
7346
7347   /* Handle non-variables up front.  */
7348   if (TREE_CODE (decl) != VAR_DECL)
7349     {
7350       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7351       return;
7352     }
7353
7354   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7355   if (asmspec)
7356     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7357
7358   if (DECL_VIRTUAL_P (decl))
7359     make_decl_rtl (decl, NULL_PTR, toplev);
7360   else if (TREE_READONLY (decl)
7361            && DECL_INITIAL (decl) != NULL_TREE
7362            && DECL_INITIAL (decl) != error_mark_node
7363            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7364     {
7365       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7366
7367       if (toplev && ! TREE_PUBLIC (decl))
7368         {
7369           /* If this is a static const, change its apparent linkage
7370              if it belongs to a #pragma interface.  */
7371           if (!interface_unknown)
7372             {
7373               TREE_PUBLIC (decl) = 1;
7374               DECL_EXTERNAL (decl) = interface_only;
7375             }
7376           make_decl_rtl (decl, asmspec, toplev);
7377         }
7378       else if (toplev)
7379         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7380     }
7381   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7382     {
7383       my_friendly_assert (TREE_STATIC (decl), 19990828);
7384
7385       if (init == NULL_TREE
7386 #ifdef DEFAULT_STATIC_DEFS
7387           /* If this code is dead, then users must
7388              explicitly declare static member variables
7389              outside the class def'n as well.  */
7390           && TYPE_NEEDS_CONSTRUCTING (type)
7391 #endif
7392           )
7393         {
7394           DECL_EXTERNAL (decl) = 1;
7395           make_decl_rtl (decl, asmspec, 1);
7396         }
7397       else
7398         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7399     }
7400   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7401            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7402     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7403 }
7404
7405 /* Create RTL for the local static variable DECL.  */
7406
7407 void
7408 make_rtl_for_local_static (decl)
7409      tree decl;
7410 {
7411   const char *asmspec = NULL;
7412
7413   /* If we inlined this variable, we could see it's declaration
7414      again.  */
7415   if (DECL_RTL (decl))
7416     return;
7417
7418   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7419     {
7420       /* The only way this situaton can occur is if the
7421          user specified a name for this DECL using the
7422          `attribute' syntax.  */
7423       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7424       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7425     }
7426
7427   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7428 }
7429
7430 /* The old ARM scoping rules injected variables declared in the
7431    initialization statement of a for-statement into the surrounding
7432    scope.  We support this usage, in order to be backward-compatible.
7433    DECL is a just-declared VAR_DECL; if necessary inject its
7434    declaration into the surrounding scope.  */
7435
7436 void
7437 maybe_inject_for_scope_var (decl)
7438      tree decl;
7439 {
7440   if (current_binding_level->is_for_scope)
7441     {
7442       struct binding_level *outer
7443         = current_binding_level->level_chain;
7444
7445       /* Check to see if the same name is already bound at the outer
7446          level, either because it was directly declared, or because a
7447          dead for-decl got preserved.  In either case, the code would
7448          not have been valid under the ARM scope rules, so clear
7449          is_for_scope for the current_binding_level.
7450
7451          Otherwise, we need to preserve the temp slot for decl to last
7452          into the outer binding level.  */
7453
7454       tree outer_binding
7455         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7456
7457       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7458           && (TREE_CODE (BINDING_VALUE (outer_binding))
7459               == VAR_DECL)
7460           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7461         {
7462           BINDING_VALUE (outer_binding)
7463             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7464           current_binding_level->is_for_scope = 0;
7465         }
7466       else if (DECL_IN_MEMORY_P (decl))
7467         preserve_temp_slots (DECL_RTL (decl));
7468     }
7469 }
7470
7471 /* Generate code to initialize DECL (a local variable).  */
7472
7473 void
7474 initialize_local_var (decl, init, flags)
7475      tree decl;
7476      tree init;
7477      int flags;
7478 {
7479   tree type = TREE_TYPE (decl);
7480
7481   /* If the type is bogus, don't bother initializing the variable.  */
7482   if (type == error_mark_node)
7483     return;
7484
7485   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7486     {
7487       /* If we used it already as memory, it must stay in memory.  */
7488       DECL_INITIAL (decl) = NULL_TREE;
7489       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7490     }
7491
7492   /* Local statics are handled differently from ordinary automatic
7493      variables.  */
7494   if (TREE_STATIC (decl))
7495     {
7496       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7497           || TYPE_NEEDS_DESTRUCTOR (type))
7498         expand_static_init (decl, init);
7499       return;
7500     }
7501
7502   if (DECL_SIZE (decl) && type != error_mark_node)
7503     {
7504       int already_used;
7505
7506       /* Compute and store the initial value.  */
7507       already_used = TREE_USED (decl) || TREE_USED (type);
7508
7509       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7510         {
7511           int saved_stmts_are_full_exprs_p;
7512
7513           emit_line_note (DECL_SOURCE_FILE (decl),
7514                           DECL_SOURCE_LINE (decl));
7515           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7516           stmts_are_full_exprs_p = 1;
7517           finish_expr_stmt (build_aggr_init (decl, init, flags));
7518           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7519         }
7520
7521       /* Set this to 0 so we can tell whether an aggregate which was
7522          initialized was ever used.  Don't do this if it has a
7523          destructor, so we don't complain about the 'resource
7524          allocation is initialization' idiom.  Now set
7525          attribute((unused)) on types so decls of that type will be
7526          marked used. (see TREE_USED, above.)  */
7527       if (TYPE_NEEDS_CONSTRUCTING (type)
7528           && ! already_used
7529           && !TYPE_NEEDS_DESTRUCTOR (type)
7530           && DECL_NAME (decl))
7531         TREE_USED (decl) = 0;
7532       else if (already_used)
7533         TREE_USED (decl) = 1;
7534     }
7535 }
7536
7537 /* Generate code to destroy DECL (a local variable).  */
7538
7539 static void
7540 destroy_local_var (decl)
7541      tree decl;
7542 {
7543   tree type = TREE_TYPE (decl);
7544   tree cleanup;
7545
7546   /* Only variables get cleaned up.  */
7547   if (TREE_CODE (decl) != VAR_DECL)
7548     return;
7549
7550   /* And only things with destructors need cleaning up.  */
7551   if (!TYPE_NEEDS_DESTRUCTOR (type))
7552     return;
7553
7554   if (TREE_CODE (decl) == VAR_DECL &&
7555       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7556     /* We don't clean up things that aren't defined in this
7557        translation unit, or that need a static cleanup.  The latter
7558        are handled by finish_file.  */
7559     return;
7560
7561   /* Compute the cleanup.  */
7562   cleanup = maybe_build_cleanup (decl);
7563
7564   /* Record the cleanup required for this declaration.  */
7565   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7566       && cleanup)
7567     finish_decl_cleanup (decl, cleanup);
7568 }
7569
7570 /* Let the back-end know about DECL.  */
7571
7572 void
7573 emit_local_var (decl)
7574      tree decl;
7575 {
7576   /* Create RTL for this variable.  */
7577   if (DECL_RTL (decl))
7578     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7579        All other local variables are assigned RTL in this function.  */
7580     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
7581                         19990828);
7582   else
7583     {
7584       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7585         /* The user must have specified an assembler name for this
7586            variable.  Set that up now.  */
7587         rest_of_decl_compilation
7588           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
7589            /*top_level=*/0, /*at_end=*/0);
7590       else
7591         expand_decl (decl);
7592     }
7593
7594   /* Actually do the initialization.  */
7595   expand_start_target_temps ();
7596   expand_decl_init (decl);
7597   expand_end_target_temps ();
7598 }
7599
7600 /* Finish processing of a declaration;
7601    install its line number and initial value.
7602    If the length of an array type is not known before,
7603    it must be determined now, from the initial value, or it is an error.
7604
7605    For C++, `cp_finish_decl' must be fairly evasive:  it must keep initializers
7606    for aggregates that have constructors alive on the permanent obstack,
7607    so that the global initializing functions can be written at the end.
7608
7609    INIT0 holds the value of an initializer that should be allowed to escape
7610    the normal rules.
7611
7612    FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7613    if the (init) syntax was used.
7614
7615    For functions that take default parameters, DECL points to its
7616    "maximal" instantiation.  `cp_finish_decl' must then also declared its
7617    subsequently lower and lower forms of instantiation, checking for
7618    ambiguity as it goes.  This can be sped up later.  */
7619
7620 void
7621 cp_finish_decl (decl, init, asmspec_tree, flags)
7622      tree decl, init;
7623      tree asmspec_tree;
7624      int flags;
7625 {
7626   register tree type;
7627   tree ttype = NULL_TREE;
7628   const char *asmspec = NULL;
7629   int was_readonly = 0;
7630
7631   /* If this is 0, then we did not change obstacks.  */
7632   if (! decl)
7633     {
7634       if (init)
7635         error ("assignment (not initialization) in declaration");
7636       return;
7637     }
7638
7639   /* Handling __FUNCTION__ and its ilk in a template-function requires
7640      some special processing because we are called from
7641      language-independent code.  */
7642   if (cfun && processing_template_decl
7643       && current_function_name_declared == 2)
7644     {
7645       /* Since we're in a template function, we need to
7646          push_template_decl.  The language-independent code in
7647          declare_hidden_char_array doesn't know to do this.  */
7648       retrofit_lang_decl (decl);
7649       decl = push_template_decl (decl);
7650
7651       if (strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
7652                   "__PRETTY_FUNCTION__") == 0)
7653         {
7654           init = build (FUNCTION_NAME, const_string_type_node);
7655           DECL_PRETTY_FUNCTION_P (decl) = 1;
7656         }
7657     }
7658
7659   /* If a name was specified, get the string.  */
7660   if (asmspec_tree)
7661       asmspec = TREE_STRING_POINTER (asmspec_tree);
7662
7663   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7664     {
7665       cp_error ("Cannot initialize `%D' to namespace `%D'",
7666                 decl, init);
7667       init = NULL_TREE;
7668     }
7669
7670   if (current_class_type
7671       && CP_DECL_CONTEXT (decl) == current_class_type
7672       && TYPE_BEING_DEFINED (current_class_type)
7673       && (DECL_INITIAL (decl) || init))
7674     DECL_DEFINED_IN_CLASS_P (decl) = 1;
7675
7676   if (TREE_CODE (decl) == VAR_DECL
7677       && DECL_CONTEXT (decl)
7678       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7679       && DECL_CONTEXT (decl) != current_namespace
7680       && init)
7681     {
7682       /* Leave the namespace of the object. */
7683       pop_decl_namespace ();
7684     }
7685
7686   type = TREE_TYPE (decl);
7687
7688   if (type == error_mark_node)
7689     return;
7690
7691   /* Add this declaration to the statement-tree.  */
7692   if (building_stmt_tree () && at_function_scope_p ())
7693     add_decl_stmt (decl);
7694
7695   if (TYPE_HAS_MUTABLE_P (type))
7696     TREE_READONLY (decl) = 0;
7697
7698   if (processing_template_decl)
7699     {
7700       if (init && DECL_INITIAL (decl))
7701         DECL_INITIAL (decl) = init;
7702       goto finish_end0;
7703     }
7704
7705   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7706   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7707
7708   /* Take care of TYPE_DECLs up front.  */
7709   if (TREE_CODE (decl) == TYPE_DECL)
7710     {
7711       if (init && DECL_INITIAL (decl))
7712         {
7713           /* typedef foo = bar; store the type of bar as the type of foo.  */
7714           TREE_TYPE (decl) = type = TREE_TYPE (init);
7715           DECL_INITIAL (decl) = init = NULL_TREE;
7716         }
7717       if (type != error_mark_node
7718           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7719         {
7720           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7721             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7722           set_identifier_type_value (DECL_NAME (decl), type);
7723           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7724         }
7725       GNU_xref_decl (current_function_decl, decl);
7726
7727       /* If we have installed this as the canonical typedef for this
7728          type, and that type has not been defined yet, delay emitting
7729          the debug information for it, as we will emit it later.  */
7730       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7731           && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
7732         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7733
7734       rest_of_decl_compilation (decl, NULL_PTR,
7735                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7736       goto finish_end;
7737     }
7738
7739   if (TREE_CODE (decl) != FUNCTION_DECL)
7740     ttype = target_type (type);
7741
7742   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7743       && TYPE_NEEDS_CONSTRUCTING (type))
7744     {
7745       /* Currently, GNU C++ puts constants in text space, making them
7746          impossible to initialize.  In the future, one would hope for
7747          an operating system which understood the difference between
7748          initialization and the running of a program.  */
7749       was_readonly = 1;
7750       TREE_READONLY (decl) = 0;
7751     }
7752
7753   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
7754     {
7755       /* This must override the asm specifier which was placed by
7756          grokclassfn.  Lay this out fresh.  */
7757       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
7758       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7759       make_decl_rtl (decl, asmspec, 0);
7760     }
7761
7762   /* Deduce size of array from initialization, if not already known.  */
7763   maybe_deduce_size_from_array_init (decl, init);
7764   init = check_initializer (decl, init);
7765
7766   GNU_xref_decl (current_function_decl, decl);
7767
7768   if (TREE_CODE (decl) == VAR_DECL)
7769     layout_var_decl (decl);
7770
7771   /* Output the assembler code and/or RTL code for variables and functions,
7772      unless the type is an undefined structure or union.
7773      If not, it will get done when the type is completed.  */
7774   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
7775       || TREE_CODE (decl) == RESULT_DECL)
7776     {
7777       if (TREE_CODE (decl) == VAR_DECL)
7778         maybe_commonize_var (decl);
7779
7780       make_rtl_for_nonlocal_decl (decl, init, asmspec);
7781
7782       if (TREE_CODE (type) == FUNCTION_TYPE
7783           || TREE_CODE (type) == METHOD_TYPE)
7784         abstract_virtuals_error (decl,
7785                                  strip_array_types (TREE_TYPE (type)));
7786       else
7787         abstract_virtuals_error (decl, strip_array_types (type));
7788
7789       if (TREE_CODE (decl) == FUNCTION_DECL)
7790         ;
7791       else if (DECL_EXTERNAL (decl)
7792                && ! (DECL_LANG_SPECIFIC (decl)
7793                      && DECL_NOT_REALLY_EXTERN (decl)))
7794         {
7795           if (init)
7796             DECL_INITIAL (decl) = init;
7797         }
7798       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
7799         {
7800           /* This is a local declaration.  */
7801           if (doing_semantic_analysis_p ())
7802             maybe_inject_for_scope_var (decl);
7803           /* Initialize the local variable.  But, if we're building a
7804              statement-tree, we'll do the initialization when we
7805              expand the tree.  */
7806           if (processing_template_decl)
7807             {
7808               if (init || DECL_INITIAL (decl) == error_mark_node)
7809                 DECL_INITIAL (decl) = init;
7810             }
7811           else
7812             {
7813               /* If we're not building RTL, then we need to do so
7814                  now.  */
7815               if (!building_stmt_tree ())
7816                 emit_local_var (decl);
7817               /* Initialize the variable.  */
7818               initialize_local_var (decl, init, flags);
7819               /* Clean up the variable.  */
7820               destroy_local_var (decl);
7821             }
7822         }
7823       else if (TREE_STATIC (decl) && type != error_mark_node)
7824         {
7825           /* Cleanups for static variables are handled by `finish_file'.  */
7826           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7827               || TYPE_NEEDS_DESTRUCTOR (type))
7828             expand_static_init (decl, init);
7829         }
7830     finish_end0:
7831
7832       /* Undo call to `pushclass' that was done in `start_decl'
7833          due to initialization of qualified member variable.
7834          I.e., Foo::x = 10;  */
7835       {
7836         tree context = CP_DECL_CONTEXT (decl);
7837         if (context
7838             && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
7839             && (TREE_CODE (decl) == VAR_DECL
7840                 /* We also have a pushclass done that we need to undo here
7841                    if we're at top level and declare a method.  */
7842                 || TREE_CODE (decl) == FUNCTION_DECL)
7843             /* If size hasn't been set, we're still defining it,
7844                and therefore inside the class body; don't pop
7845                the binding level..  */
7846             && TYPE_SIZE (context) != NULL_TREE
7847             && context == current_class_type)
7848           pop_nested_class ();
7849       }
7850     }
7851
7852  finish_end:
7853
7854   if (was_readonly)
7855     TREE_READONLY (decl) = 1;
7856 }
7857
7858 /* This is here for a midend callback from c-common.c */
7859
7860 void
7861 finish_decl (decl, init, asmspec_tree)
7862      tree decl, init;
7863      tree asmspec_tree;
7864 {
7865   cp_finish_decl (decl, init, asmspec_tree, 0);
7866 }
7867
7868 /* Returns a declaration for a VAR_DECL as if:
7869
7870      extern "C" TYPE NAME;
7871
7872    had been seen.  Used to create compiler-generated global
7873    variables.  */
7874
7875 tree
7876 declare_global_var (name, type)
7877      tree name;
7878      tree type;
7879 {
7880   tree decl;
7881
7882   push_to_top_level ();
7883   decl = build_decl (VAR_DECL, name, type);
7884   TREE_PUBLIC (decl) = 1;
7885   DECL_EXTERNAL (decl) = 1;
7886   DECL_ARTIFICIAL (decl) = 1;
7887   pushdecl (decl);
7888   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
7889   pop_from_top_level ();
7890
7891   return decl;
7892 }
7893
7894 /* Returns a pointer to the `atexit' function.  Note that if
7895    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
7896    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
7897
7898 static tree
7899 get_atexit_node ()
7900 {
7901   tree atexit_fndecl;
7902   tree arg_types;
7903   tree fn_type;
7904   tree fn_ptr_type;
7905   const char *name;
7906
7907   if (atexit_node)
7908     return atexit_node;
7909
7910   if (flag_use_cxa_atexit)
7911     {
7912       /* The declaration for `__cxa_atexit' is:
7913
7914            int __cxa_atexit (void (*)(void *), void *, void *)
7915
7916          We build up the argument types and then then function type
7917          itself.  */
7918
7919       /* First, build the pointer-to-function type for the first
7920          argument.  */
7921       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7922       fn_type = build_function_type (void_type_node, arg_types);
7923       fn_ptr_type = build_pointer_type (fn_type);
7924       /* Then, build the rest of the argument types.  */
7925       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7926       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
7927       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
7928       /* And the final __cxa_atexit type.  */
7929       fn_type = build_function_type (integer_type_node, arg_types);
7930       fn_ptr_type = build_pointer_type (fn_type);
7931       name = "__cxa_atexit";
7932     }
7933   else
7934     {
7935       /* The declaration for `atexit' is:
7936
7937            int atexit (void (*)());
7938
7939          We build up the argument types and then then function type
7940          itself.  */
7941       fn_type = build_function_type (void_type_node, void_list_node);
7942       fn_ptr_type = build_pointer_type (fn_type);
7943       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
7944       /* Build the final atexit type.  */
7945       fn_type = build_function_type (integer_type_node, arg_types);
7946       name = "atexit";
7947     }
7948
7949   /* Now, build the function declaration.  */
7950   push_lang_context (lang_name_c);
7951   atexit_fndecl = define_function (name, fn_type, /*pfn=*/0, NULL_PTR);
7952   mark_used (atexit_fndecl);
7953   pop_lang_context ();
7954   atexit_node = default_conversion (atexit_fndecl);
7955
7956   return atexit_node;
7957 }
7958
7959 /* Returns the __dso_handle VAR_DECL.  */
7960
7961 static tree
7962 get_dso_handle_node ()
7963 {
7964   if (dso_handle_node)
7965     return dso_handle_node;
7966
7967   /* Declare the variable.  */
7968   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
7969                                         ptr_type_node);
7970
7971   return dso_handle_node;
7972 }
7973
7974 /* Begin a new function with internal linkage whose job will be simply
7975    to destroy some particular variable.  */
7976
7977 static tree
7978 start_cleanup_fn ()
7979 {
7980   static int counter = 0;
7981   int old_interface_unknown = interface_unknown;
7982   char name[32];
7983   tree parmtypes;
7984   tree fntype;
7985   tree fndecl;
7986
7987   push_to_top_level ();
7988
7989   /* No need to mangle this.  */
7990   push_lang_context (lang_name_c);
7991
7992   interface_unknown = 1;
7993
7994   /* Build the parameter-types.  */
7995   parmtypes = void_list_node;
7996   /* Functions passed to __cxa_atexit take an additional parameter.
7997      We'll just ignore it.  After we implement the new calling
7998      convention for destructors, we can eliminate the use of
7999      additional cleanup functions entirely in the -fnew-abi case.  */
8000   if (flag_use_cxa_atexit)
8001     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8002   /* Build the function type itself.  */
8003   fntype = build_function_type (void_type_node, parmtypes);
8004   /* Build the name of the function.  */
8005   sprintf (name, "__tcf_%d", counter++);
8006   /* Build the function declaration.  */
8007   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8008   /* It's a function with internal linkage, generated by the
8009      compiler.  */
8010   TREE_PUBLIC (fndecl) = 0;
8011   DECL_ARTIFICIAL (fndecl) = 1;
8012   /* Build the parameter.  */
8013   if (flag_use_cxa_atexit)
8014     {
8015       tree parmdecl;
8016
8017       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8018       DECL_CONTEXT (parmdecl) = fndecl;
8019       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8020       TREE_USED (parmdecl) = 1;
8021       DECL_ARGUMENTS (fndecl) = parmdecl;
8022     }
8023
8024   pushdecl (fndecl);
8025   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8026   do_pushlevel ();
8027
8028   interface_unknown = old_interface_unknown;
8029
8030   pop_lang_context ();
8031
8032   return current_function_decl;
8033 }
8034
8035 /* Finish the cleanup function begun by start_cleanup_fn.  */
8036
8037 static void
8038 end_cleanup_fn ()
8039 {
8040   do_poplevel ();
8041
8042   expand_body (finish_function (lineno, 0));
8043
8044   pop_from_top_level ();
8045 }
8046
8047 /* Generate code to handle the destruction of DECL, an object with
8048    static storage duration.  */
8049
8050 void
8051 register_dtor_fn (decl)
8052      tree decl;
8053 {
8054   tree cleanup;
8055   tree compound_stmt;
8056   tree args;
8057   tree fcall;
8058
8059   int saved_flag_access_control;
8060
8061   if (!TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
8062     return;
8063
8064   /* Call build_cleanup before we enter the anonymous function so that
8065      any access checks will be done relative to the current scope,
8066      rather than the scope of the anonymous function.  */
8067   build_cleanup (decl);
8068
8069   /* Now start the function.  */
8070   cleanup = start_cleanup_fn ();
8071
8072   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8073      to the original function, rather than the anonymous one.  That
8074      will make the back-end think that nested functions are in use,
8075      which causes confusion.  */
8076   saved_flag_access_control = flag_access_control;
8077   flag_access_control = 0;
8078   fcall = build_cleanup (decl);
8079   flag_access_control = saved_flag_access_control;
8080
8081   /* Create the body of the anonymous function.  */
8082   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8083   finish_expr_stmt (fcall);
8084   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8085   end_cleanup_fn ();
8086
8087   /* Call atexit with the cleanup function.  */
8088   mark_addressable (cleanup);
8089   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8090   if (flag_use_cxa_atexit)
8091     {
8092       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8093       args = tree_cons (NULL_TREE, null_pointer_node, args);
8094       args = tree_cons (NULL_TREE, cleanup, args);
8095     }
8096   else
8097     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8098   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8099 }
8100
8101 void
8102 expand_static_init (decl, init)
8103      tree decl;
8104      tree init;
8105 {
8106   tree oldstatic = value_member (decl, static_aggregates);
8107
8108   if (oldstatic)
8109     {
8110       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8111         cp_error ("multiple initializations given for `%D'", decl);
8112     }
8113   else if (! toplevel_bindings_p ())
8114     {
8115       /* Emit code to perform this initialization but once.  */
8116       tree temp;
8117       tree if_stmt;
8118       tree then_clause;
8119       tree assignment;
8120       tree temp_init;
8121
8122       /* Emit code to perform this initialization but once.  This code
8123          looks like:
8124
8125            static int temp = 0;
8126            if (!temp) {
8127              // Do initialization.
8128              temp = 1;
8129              // Register variable for destruction at end of program.
8130            }
8131
8132          Note that the `temp' variable is only set to 1 *after* the
8133          initialization is complete.  This ensures that an exception,
8134          thrown during the construction, will cause the variable to
8135          reinitialized when we pass through this code again, as per:
8136
8137            [stmt.dcl]
8138
8139            If the initialization exits by throwing an exception, the
8140            initialization is not complete, so it will be tried again
8141            the next time control enters the declaration.
8142
8143          In theory, this process should be thread-safe, too; multiple
8144          threads should not be able to initialize the variable more
8145          than once.  We don't yet attempt to ensure thread-safety.  */
8146       temp = get_temp_name (integer_type_node, 1);
8147       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8148
8149       /* Begin the conditional initialization.  */
8150       if_stmt = begin_if_stmt ();
8151       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8152                                             integer_zero_node),
8153                            if_stmt);
8154       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8155
8156       /* Do the initialization itself.  */
8157       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8158           || (init && TREE_CODE (init) == TREE_LIST))
8159         assignment = build_aggr_init (decl, init, 0);
8160       else if (init)
8161         /* The initialization we're doing here is just a bitwise
8162            copy.  */
8163         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8164       else
8165         assignment = NULL_TREE;
8166
8167       /* Once the assignment is complete, set TEMP to 1.  Since the
8168          construction of the static object is complete at this point,
8169          we want to make sure TEMP is set to 1 even if a temporary
8170          constructed during the initialization throws an exception
8171          when it is destroyed.  So, we combine the initialization and
8172          the assignment to TEMP into a single expression, ensuring
8173          that when we call finish_expr_stmt the cleanups will not be
8174          run until after TEMP is set to 1.  */
8175       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8176       if (assignment)
8177         {
8178           assignment = tree_cons (NULL_TREE, assignment,
8179                                   build_tree_list (NULL_TREE,
8180                                                    temp_init));
8181           assignment = build_compound_expr (assignment);
8182         }
8183       else
8184         assignment = temp_init;
8185       finish_expr_stmt (assignment);
8186
8187       /* Use atexit to register a function for destroying this static
8188          variable.  */
8189       register_dtor_fn (decl);
8190
8191       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8192       finish_then_clause (if_stmt);
8193       finish_if_stmt ();
8194     }
8195   else
8196     static_aggregates = tree_cons (init, decl, static_aggregates);
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, flags)
8313      tree ctype, cur_type;
8314      enum overload_flags flags;
8315 {
8316   if (ctype && ctype != cur_type)
8317     {
8318       if (flags == DTOR_FLAG)
8319         error ("destructor for alien class `%s' cannot be a member",
8320                TYPE_NAME_STRING (ctype));
8321       else
8322         error ("constructor for alien class `%s' cannot be a member",
8323                TYPE_NAME_STRING (ctype));
8324       return 0;
8325     }
8326   return 1;
8327 }
8328 \f
8329 /* Subroutine of `grokdeclarator'.  */
8330
8331 /* Generate errors possibly applicable for a given set of specifiers.
8332    This is for ARM $7.1.2.  */
8333
8334 static void
8335 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8336      tree object;
8337      const char *type;
8338      int virtualp, quals, friendp, raises, inlinep;
8339 {
8340   if (virtualp)
8341     cp_error ("`%D' declared as a `virtual' %s", object, type);
8342   if (inlinep)
8343     cp_error ("`%D' declared as an `inline' %s", object, type);
8344   if (quals)
8345     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8346               object, type);
8347   if (friendp)
8348     cp_error_at ("`%D' declared as a friend", object);
8349   if (raises)
8350     cp_error_at ("`%D' declared with an exception specification", object);
8351 }
8352
8353 /* CTYPE is class type, or null if non-class.
8354    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8355    or METHOD_TYPE.
8356    DECLARATOR is the function's name.
8357    VIRTUALP is truthvalue of whether the function is virtual or not.
8358    FLAGS are to be passed through to `grokclassfn'.
8359    QUALS are qualifiers indicating whether the function is `const'
8360    or `volatile'.
8361    RAISES is a list of exceptions that this function can raise.
8362    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8363    not look, and -1 if we should not call `grokclassfn' at all.
8364
8365    Returns `NULL_TREE' if something goes wrong, after issuing
8366    applicable error messages.  */
8367
8368 static tree
8369 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8370             raises, check, friendp, publicp, inlinep, funcdef_flag,
8371             template_count, in_namespace)
8372      tree ctype, type;
8373      tree declarator;
8374      tree orig_declarator;
8375      int virtualp;
8376      enum overload_flags flags;
8377      tree quals, raises;
8378      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8379      tree in_namespace;
8380 {
8381   tree cname, decl;
8382   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8383   int has_default_arg = 0;
8384   tree t;
8385
8386   if (ctype)
8387     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8388       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8389   else
8390     cname = NULL_TREE;
8391
8392   if (raises)
8393     {
8394       type = build_exception_variant (type, raises);
8395     }
8396
8397   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8398   /* Propagate volatile out from type to decl. */
8399   if (TYPE_VOLATILE (type))
8400     TREE_THIS_VOLATILE (decl) = 1;
8401
8402   /* If this decl has namespace scope, set that up.  */
8403   if (in_namespace)
8404     set_decl_namespace (decl, in_namespace, friendp);
8405   else if (publicp && ! ctype)
8406     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8407
8408   /* `main' and builtins have implicit 'C' linkage.  */
8409   if ((MAIN_NAME_P (declarator)
8410        || (IDENTIFIER_LENGTH (declarator) > 10
8411            && IDENTIFIER_POINTER (declarator)[0] == '_'
8412            && IDENTIFIER_POINTER (declarator)[1] == '_'
8413            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8414       && current_lang_name == lang_name_cplusplus
8415       && ctype == NULL_TREE
8416       /* NULL_TREE means global namespace.  */
8417       && DECL_CONTEXT (decl) == NULL_TREE)
8418     DECL_LANGUAGE (decl) = lang_c;
8419
8420   /* Should probably propagate const out from type to decl I bet (mrs).  */
8421   if (staticp)
8422     {
8423       DECL_STATIC_FUNCTION_P (decl) = 1;
8424       DECL_CONTEXT (decl) = ctype;
8425     }
8426
8427   if (ctype)
8428     DECL_CONTEXT (decl) = ctype;
8429
8430   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8431     {
8432       if (processing_template_decl)
8433         error ("cannot declare `::main' to be a template");
8434       if (inlinep)
8435         error ("cannot declare `::main' to be inline");
8436       else if (! publicp)
8437         error ("cannot declare `::main' to be static");
8438       inlinep = 0;
8439       publicp = 1;
8440     }
8441
8442   /* Members of anonymous types and local classes have no linkage; make
8443      them internal.  */
8444   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8445                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8446     publicp = 0;
8447
8448   if (publicp)
8449     {
8450       /* [basic.link]: A name with no linkage (notably, the name of a class
8451          or enumeration declared in a local scope) shall not be used to
8452          declare an entity with linkage.
8453
8454          Only check this for public decls for now.  */
8455       t = no_linkage_check (TREE_TYPE (decl));
8456       if (t)
8457         {
8458           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8459             {
8460               if (DECL_LANGUAGE (decl) == lang_c)
8461                 /* Allow this; it's pretty common in C.  */;
8462               else
8463                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8464                             decl);
8465             }
8466           else
8467             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8468                         decl, t);
8469         }
8470     }
8471
8472   TREE_PUBLIC (decl) = publicp;
8473   if (! publicp)
8474     {
8475       DECL_INTERFACE_KNOWN (decl) = 1;
8476       DECL_NOT_REALLY_EXTERN (decl) = 1;
8477     }
8478
8479   if (inlinep)
8480     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8481
8482   DECL_EXTERNAL (decl) = 1;
8483   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8484     {
8485       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8486                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8487       quals = NULL_TREE;
8488     }
8489
8490   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8491     grok_op_properties (decl, virtualp, check < 0);
8492
8493   if (ctype && decl_function_context (decl))
8494     DECL_NO_STATIC_CHAIN (decl) = 1;
8495
8496   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8497     if (TREE_PURPOSE (t)
8498         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8499       {
8500         has_default_arg = 1;
8501         break;
8502       }
8503
8504   if (friendp
8505       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8506     {
8507       if (funcdef_flag)
8508         cp_error
8509           ("defining explicit specialization `%D' in friend declaration",
8510            orig_declarator);
8511       else
8512         {
8513           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8514             {
8515               /* Something like `template <class T> friend void f<T>()'.  */
8516               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8517                         orig_declarator);
8518               return NULL_TREE;
8519             }
8520
8521
8522           /* A friend declaration of the form friend void f<>().  Record
8523              the information in the TEMPLATE_ID_EXPR.  */
8524           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8525           DECL_TEMPLATE_INFO (decl)
8526             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8527                          TREE_OPERAND (orig_declarator, 1),
8528                          NULL_TREE);
8529
8530           if (has_default_arg)
8531             {
8532               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8533                         decl);
8534               return NULL_TREE;
8535             }
8536
8537           if (inlinep)
8538             {
8539               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8540                         decl);
8541               return NULL_TREE;
8542             }
8543         }
8544     }
8545
8546   if (has_default_arg)
8547     add_defarg_fn (decl);
8548
8549   /* Plain overloading: will not be grok'd by grokclassfn.  */
8550   if (! ctype && ! processing_template_decl
8551       && DECL_LANGUAGE (decl) != lang_c
8552       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8553     set_mangled_name_for_decl (decl);
8554
8555   if (funcdef_flag)
8556     /* Make the init_value nonzero so pushdecl knows this is not
8557        tentative.  error_mark_node is replaced later with the BLOCK.  */
8558     DECL_INITIAL (decl) = error_mark_node;
8559
8560   /* Caller will do the rest of this.  */
8561   if (check < 0)
8562     return decl;
8563
8564   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8565     {
8566       tree tmp;
8567       /* Just handle constructors here.  We could do this
8568          inside the following if stmt, but I think
8569          that the code is more legible by breaking this
8570          case out.  See comments below for what each of
8571          the following calls is supposed to do.  */
8572       DECL_CONSTRUCTOR_P (decl) = 1;
8573
8574       grokclassfn (ctype, decl, flags, quals);
8575
8576       decl = check_explicit_specialization (orig_declarator, decl,
8577                                             template_count,
8578                                             2 * (funcdef_flag != 0) +
8579                                             4 * (friendp != 0));
8580       if (decl == error_mark_node)
8581         return NULL_TREE;
8582
8583       if ((! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8584           && check)
8585         {
8586           tmp = check_classfn (ctype, decl);
8587
8588           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8589             tmp = DECL_TEMPLATE_RESULT(tmp);
8590
8591           if (tmp && DECL_ARTIFICIAL (tmp))
8592             cp_error ("definition of implicitly-declared `%D'", tmp);
8593           if (tmp && duplicate_decls (decl, tmp))
8594             return tmp;
8595         }
8596       if (! grok_ctor_properties (ctype, decl))
8597         return NULL_TREE;
8598     }
8599   else
8600     {
8601       tree tmp;
8602
8603       /* Function gets the ugly name, field gets the nice one.
8604          This call may change the type of the function (because
8605          of default parameters)!  */
8606       if (ctype != NULL_TREE)
8607         grokclassfn (ctype, decl, flags, quals);
8608
8609       decl = check_explicit_specialization (orig_declarator, decl,
8610                                             template_count,
8611                                             2 * (funcdef_flag != 0) +
8612                                             4 * (friendp != 0));
8613       if (decl == error_mark_node)
8614         return NULL_TREE;
8615
8616       if (ctype != NULL_TREE
8617           && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8618           && check)
8619         {
8620           tmp = check_classfn (ctype, decl);
8621
8622           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8623             tmp = DECL_TEMPLATE_RESULT (tmp);
8624
8625           if (tmp && DECL_STATIC_FUNCTION_P (tmp)
8626               && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8627             {
8628               /* Remove the `this' parm added by grokclassfn.
8629                  XXX Isn't this done in start_function, too?  */
8630               revert_static_member_fn (&decl, NULL, NULL);
8631               last_function_parms = TREE_CHAIN (last_function_parms);
8632             }
8633           if (tmp && DECL_ARTIFICIAL (tmp))
8634             cp_error ("definition of implicitly-declared `%D'", tmp);
8635           if (tmp)
8636             {
8637               /* Attempt to merge the declarations.  This can fail, in
8638                  the case of some illegal specialization declarations.  */
8639               if (!duplicate_decls (decl, tmp))
8640                 cp_error ("no `%#D' member function declared in class `%T'",
8641                           decl, ctype);
8642               return tmp;
8643             }
8644         }
8645
8646       if (ctype == NULL_TREE || check)
8647         return decl;
8648
8649       if (virtualp)
8650         {
8651           DECL_VIRTUAL_P (decl) = 1;
8652           if (DECL_VINDEX (decl) == NULL_TREE)
8653             DECL_VINDEX (decl) = error_mark_node;
8654           IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8655         }
8656     }
8657   return decl;
8658 }
8659
8660 static tree
8661 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8662      tree type;
8663      tree declarator;
8664      RID_BIT_TYPE *specbits_in;
8665      int initialized;
8666      int constp;
8667      tree in_namespace;
8668 {
8669   tree decl;
8670   RID_BIT_TYPE specbits;
8671
8672   specbits = *specbits_in;
8673
8674   if (TREE_CODE (type) == OFFSET_TYPE)
8675     {
8676       /* If you declare a static member so that it
8677          can be initialized, the code will reach here.  */
8678       tree basetype = TYPE_OFFSET_BASETYPE (type);
8679       type = TREE_TYPE (type);
8680       decl = build_lang_decl (VAR_DECL, declarator, type);
8681       DECL_CONTEXT (decl) = basetype;
8682       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8683     }
8684   else
8685     {
8686       tree context;
8687
8688       if (in_namespace)
8689         context = in_namespace;
8690       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8691         context = current_namespace;
8692       else
8693         context = NULL_TREE;
8694
8695       if (processing_template_decl)
8696         /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8697            we can call push_template_decl.  */
8698         decl = build_lang_decl (VAR_DECL, declarator, type);
8699       else
8700         decl = build_decl (VAR_DECL, declarator, type);
8701
8702       if (context)
8703         set_decl_namespace (decl, context, 0);
8704
8705       context = DECL_CONTEXT (decl);
8706       if (declarator && context && current_lang_name != lang_name_c)
8707         DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8708     }
8709
8710   if (in_namespace)
8711     set_decl_namespace (decl, in_namespace, 0);
8712
8713   if (RIDBIT_SETP (RID_EXTERN, specbits))
8714     {
8715       DECL_THIS_EXTERN (decl) = 1;
8716       DECL_EXTERNAL (decl) = !initialized;
8717     }
8718
8719   /* In class context, static means one per class,
8720      public access, and static storage.  */
8721   if (DECL_CLASS_SCOPE_P (decl))
8722     {
8723       TREE_PUBLIC (decl) = 1;
8724       TREE_STATIC (decl) = 1;
8725       DECL_EXTERNAL (decl) = 0;
8726     }
8727   /* At top level, either `static' or no s.c. makes a definition
8728      (perhaps tentative), and absence of `static' makes it public.  */
8729   else if (toplevel_bindings_p ())
8730     {
8731       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8732                             && (DECL_THIS_EXTERN (decl) || ! constp));
8733       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8734     }
8735   /* Not at top level, only `static' makes a static definition.  */
8736   else
8737     {
8738       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8739       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8740     }
8741
8742   if (TREE_PUBLIC (decl))
8743     {
8744       /* [basic.link]: A name with no linkage (notably, the name of a class
8745          or enumeration declared in a local scope) shall not be used to
8746          declare an entity with linkage.
8747
8748          Only check this for public decls for now.  */
8749       tree t = no_linkage_check (TREE_TYPE (decl));
8750       if (t)
8751         {
8752           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8753             /* Ignore for now; `enum { foo } e' is pretty common.  */;
8754           else
8755             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8756                         decl, t);
8757         }
8758     }
8759
8760   return decl;
8761 }
8762
8763 /* Create and return a canonical pointer to member function type, for
8764    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
8765
8766 tree
8767 build_ptrmemfunc_type (type)
8768      tree type;
8769 {
8770   tree fields[4];
8771   tree t;
8772   tree u;
8773   tree unqualified_variant = NULL_TREE;
8774
8775   /* If a canonical type already exists for this type, use it.  We use
8776      this method instead of type_hash_canon, because it only does a
8777      simple equality check on the list of field members.  */
8778
8779   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8780     return t;
8781
8782   /* Make sure that we always have the unqualified pointer-to-member
8783      type first.  */
8784   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8785     unqualified_variant
8786       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
8787
8788   t = make_aggr_type (RECORD_TYPE);
8789   /* Let the front-end know this is a pointer to member function...  */
8790   TYPE_PTRMEMFUNC_FLAG (t) = 1;
8791   /* ... and not really an aggregate.  */
8792   SET_IS_AGGR_TYPE (t, 0);
8793
8794   if (!flag_new_abi)
8795     {
8796       u = make_aggr_type (UNION_TYPE);
8797       SET_IS_AGGR_TYPE (u, 0);
8798       fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
8799       fields[1] = build_lang_decl (FIELD_DECL, delta2_identifier,
8800                                    delta_type_node);
8801       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
8802       TYPE_NAME (u) = NULL_TREE;
8803
8804       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
8805                                    delta_type_node);
8806       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
8807                                    delta_type_node);
8808       fields[2] = build_lang_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
8809       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
8810     }
8811   else
8812     {
8813       fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
8814       fields[1] = build_lang_decl (FIELD_DECL, delta_identifier,
8815                                    delta_type_node);
8816       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
8817     }
8818
8819   /* Zap out the name so that the back-end will give us the debugging
8820      information for this anonymous RECORD_TYPE.  */
8821   TYPE_NAME (t) = NULL_TREE;
8822
8823   /* If this is not the unqualified form of this pointer-to-member
8824      type, set the TYPE_MAIN_VARIANT for this type to be the
8825      unqualified type.  Since they are actually RECORD_TYPEs that are
8826      not variants of each other, we must do this manually.  */
8827   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8828     {
8829       t = build_qualified_type (t, CP_TYPE_QUALS (type));
8830       TYPE_MAIN_VARIANT (t) = unqualified_variant;
8831       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
8832       TYPE_NEXT_VARIANT (unqualified_variant) = t;
8833     }
8834
8835   /* Cache this pointer-to-member type so that we can find it again
8836      later.  */
8837   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
8838
8839   /* Seems to be wanted.  */
8840   CLASSTYPE_GOT_SEMICOLON (t) = 1;
8841
8842   return t;
8843 }
8844
8845 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8846    Check to see that the definition is valid.  Issue appropriate error
8847    messages.  Return 1 if the definition is particularly bad, or 0
8848    otherwise.  */
8849
8850 int
8851 check_static_variable_definition (decl, type)
8852      tree decl;
8853      tree type;
8854 {
8855   /* Motion 10 at San Diego: If a static const integral data member is
8856      initialized with an integral constant expression, the initializer
8857      may appear either in the declaration (within the class), or in
8858      the definition, but not both.  If it appears in the class, the
8859      member is a member constant.  The file-scope definition is always
8860      required.  */
8861   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
8862     {
8863       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
8864                 type);
8865       /* If we just return the declaration, crashes will sometimes
8866          occur.  We therefore return void_type_node, as if this was a
8867          friend declaration, to cause callers to completely ignore
8868          this declaration.  */
8869       return 1;
8870     }
8871   else if (!CP_TYPE_CONST_P (type))
8872     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
8873               decl);
8874   else if (pedantic && !INTEGRAL_TYPE_P (type))
8875     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
8876
8877   return 0;
8878 }
8879
8880 /* Given the SIZE (i.e., number of elements) in an array, compute an
8881    appropriate index type for the array.  If non-NULL, NAME is the
8882    name of the thing being declared.  */
8883
8884 tree
8885 compute_array_index_type (name, size)
8886      tree name;
8887      tree size;
8888 {
8889   tree itype;
8890
8891   /* The size might be the result of a cast. */
8892   STRIP_TYPE_NOPS (size);
8893
8894   /* It might be a const variable or enumeration constant.  */
8895   if (TREE_READONLY_DECL_P (size))
8896     size = decl_constant_value (size);
8897
8898   /* If this involves a template parameter, it will be a constant at
8899      instantiation time, but we don't know what the value is yet.
8900      Even if no template parameters are involved, we may an expression
8901      that is not a constant; we don't even simplify `1 + 2' when
8902      processing a template.  */
8903   if (processing_template_decl)
8904     {
8905       /* Resolve a qualified reference to an enumerator or static
8906          const data member of ours.  */
8907       if (TREE_CODE (size) == SCOPE_REF
8908           && TREE_OPERAND (size, 0) == current_class_type)
8909         {
8910           tree t = lookup_field (current_class_type,
8911                                  TREE_OPERAND (size, 1), 0, 0);
8912           if (t)
8913             size = t;
8914         }
8915
8916       return build_index_type (build_min (MINUS_EXPR, sizetype,
8917                                           size, integer_one_node));
8918     }
8919
8920   /* The array bound must be an integer type.  */
8921   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
8922       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
8923       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
8924     {
8925       if (name)
8926         cp_error ("size of array `%D' has non-integer type", name);
8927       else
8928         cp_error ("size of array has non-integer type");
8929       size = integer_one_node;
8930     }
8931
8932   /* Normally, the array-bound will be a constant.  */
8933   if (TREE_CONSTANT (size))
8934     {
8935       /* Check to see if the array bound overflowed.  Make that an
8936          error, no matter how generous we're being.  */
8937       int old_flag_pedantic_errors = flag_pedantic_errors;
8938       int old_pedantic = pedantic;
8939       pedantic = flag_pedantic_errors = 1;
8940       constant_expression_warning (size);
8941       pedantic = old_pedantic;
8942       flag_pedantic_errors = old_flag_pedantic_errors;
8943
8944       /* An array must have a positive number of elements.  */
8945       if (INT_CST_LT (size, integer_zero_node))
8946         {
8947           if (name)
8948             cp_error ("size of array `%D' is negative", name);
8949           else
8950             cp_error ("size of array is negative");
8951           size = integer_one_node;
8952         }
8953       /* Except that an extension we allow zero-sized arrays.  We
8954          always allow them in system headers because glibc uses
8955          them.  */
8956       else if (integer_zerop (size) && pedantic && !in_system_header)
8957         {
8958           if (name)
8959             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
8960           else
8961             cp_pedwarn ("ISO C++ forbids zero-size array");
8962         }
8963     }
8964
8965   /* Compute the index of the largest element in the array.  It is
8966      one less than the number of elements in the array.  */
8967   itype
8968     = fold (build_binary_op (MINUS_EXPR,
8969                              cp_convert (ssizetype, size),
8970                              cp_convert (ssizetype,
8971                                          integer_one_node)));
8972
8973   /* Check for variable-sized arrays.  We allow such things as an
8974      extension, even though they are not allowed in ANSI/ISO C++.  */
8975   if (!TREE_CONSTANT (itype))
8976     {
8977       if (pedantic)
8978         {
8979           if (name)
8980             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
8981                         name);
8982           else
8983             cp_pedwarn ("ISO C++ forbids variable-size array");
8984         }
8985
8986       /* Create a variable-sized array index type.  */
8987       itype = variable_size (itype);
8988     }
8989   /* Make sure that there was no overflow when creating to a signed
8990      index type.  (For example, on a 32-bit machine, an array with
8991      size 2^32 - 1 is too big.)  */
8992   else if (TREE_OVERFLOW (itype))
8993     {
8994       error ("overflow in array dimension");
8995       TREE_OVERFLOW (itype) = 0;
8996     }
8997
8998   /* Create and return the appropriate index type.  */
8999   return build_index_type (itype);
9000 }
9001
9002 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9003    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9004    with this type.  */
9005
9006 static tree
9007 create_array_type_for_decl (name, type, size)
9008      tree name;
9009      tree type;
9010      tree size;
9011 {
9012   tree itype = NULL_TREE;
9013   const char* error_msg;
9014
9015   /* If things have already gone awry, bail now.  */
9016   if (type == error_mark_node || size == error_mark_node)
9017     return error_mark_node;
9018
9019   /* Assume that everything will go OK.  */
9020   error_msg = NULL;
9021
9022   /* There are some types which cannot be array elements.  */
9023   switch (TREE_CODE (type))
9024     {
9025     case VOID_TYPE:
9026       error_msg = "array of void";
9027       break;
9028
9029     case FUNCTION_TYPE:
9030       error_msg = "array of functions";
9031       break;
9032
9033     case REFERENCE_TYPE:
9034       error_msg = "array of references";
9035       break;
9036
9037     case OFFSET_TYPE:
9038       error_msg = "array of data members";
9039       break;
9040
9041     case METHOD_TYPE:
9042       error_msg = "array of function members";
9043       break;
9044
9045     default:
9046       break;
9047     }
9048
9049   /* If something went wrong, issue an error-message and return.  */
9050   if (error_msg)
9051     {
9052       if (name)
9053         cp_error ("declaration of `%D' as %s", name, error_msg);
9054       else
9055         cp_error ("creating %s", error_msg);
9056
9057       return error_mark_node;
9058     }
9059
9060   /* [dcl.array]
9061
9062      The constant expressions that specify the bounds of the arrays
9063      can be omitted only for the first member of the sequence.  */
9064   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9065     {
9066       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9067                 name);
9068
9069       return error_mark_node;
9070     }
9071
9072   /* Figure out the index type for the array.  */
9073   if (size)
9074     itype = compute_array_index_type (name, size);
9075
9076   return build_cplus_array_type (type, itype);
9077 }
9078
9079 /* Given declspecs and a declarator,
9080    determine the name and type of the object declared
9081    and construct a ..._DECL node for it.
9082    (In one case we can return a ..._TYPE node instead.
9083     For invalid input we sometimes return 0.)
9084
9085    DECLSPECS is a chain of tree_list nodes whose value fields
9086     are the storage classes and type specifiers.
9087
9088    DECL_CONTEXT says which syntactic context this declaration is in:
9089      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9090      FUNCDEF for a function definition.  Like NORMAL but a few different
9091       error messages in each case.  Return value may be zero meaning
9092       this definition is too screwy to try to parse.
9093      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9094       handle member functions (which have FIELD context).
9095       Return value may be zero meaning this definition is too screwy to
9096       try to parse.
9097      PARM for a parameter declaration (either within a function prototype
9098       or before a function body).  Make a PARM_DECL, or return void_type_node.
9099      CATCHPARM for a parameter declaration before a catch clause.
9100      TYPENAME if for a typename (in a cast or sizeof).
9101       Don't make a DECL node; just return the ..._TYPE node.
9102      FIELD for a struct or union field; make a FIELD_DECL.
9103      BITFIELD for a field with specified width.
9104    INITIALIZED is 1 if the decl has an initializer.
9105
9106    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9107    normal attributes in TREE_PURPOSE, or NULL_TREE.
9108
9109    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9110    It may also be so in the PARM case, for a prototype where the
9111    argument type is specified but not the name.
9112
9113    This function is where the complicated C meanings of `static'
9114    and `extern' are interpreted.
9115
9116    For C++, if there is any monkey business to do, the function which
9117    calls this one must do it, i.e., prepending instance variables,
9118    renaming overloaded function names, etc.
9119
9120    Note that for this C++, it is an error to define a method within a class
9121    which does not belong to that class.
9122
9123    Except in the case where SCOPE_REFs are implicitly known (such as
9124    methods within a class being redundantly qualified),
9125    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9126    (class_name::decl_name).  The caller must also deal with this.
9127
9128    If a constructor or destructor is seen, and the context is FIELD,
9129    then the type gains the attribute TREE_HAS_x.  If such a declaration
9130    is erroneous, NULL_TREE is returned.
9131
9132    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9133    function, these are the qualifiers to give to the `this' pointer. We
9134    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9135
9136    May return void_type_node if the declarator turned out to be a friend.
9137    See grokfield for details.  */
9138
9139 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
9140
9141 tree
9142 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9143      tree declspecs;
9144      tree declarator;
9145      enum decl_context decl_context;
9146      int initialized;
9147      tree attrlist;
9148 {
9149   RID_BIT_TYPE specbits;
9150   int nclasses = 0;
9151   tree spec;
9152   tree type = NULL_TREE;
9153   int longlong = 0;
9154   int constp;
9155   int restrictp;
9156   int volatilep;
9157   int type_quals;
9158   int virtualp, explicitp, friendp, inlinep, staticp;
9159   int explicit_int = 0;
9160   int explicit_char = 0;
9161   int defaulted_int = 0;
9162   tree typedef_decl = NULL_TREE;
9163   const char *name;
9164   tree typedef_type = NULL_TREE;
9165   int funcdef_flag = 0;
9166   enum tree_code innermost_code = ERROR_MARK;
9167   int bitfield = 0;
9168 #if 0
9169   /* See the code below that used this.  */
9170   tree decl_machine_attr = NULL_TREE;
9171 #endif
9172   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9173      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9174   tree init = NULL_TREE;
9175
9176   /* Keep track of what sort of function is being processed
9177      so that we can warn about default return values, or explicit
9178      return values which do not match prescribed defaults.  */
9179   enum return_types return_type = return_normal;
9180
9181   tree dname = NULL_TREE;
9182   tree ctype = current_class_type;
9183   tree ctor_return_type = NULL_TREE;
9184   enum overload_flags flags = NO_SPECIAL;
9185   tree quals = NULL_TREE;
9186   tree raises = NULL_TREE;
9187   int template_count = 0;
9188   tree in_namespace = NULL_TREE;
9189   tree inner_attrs;
9190   int ignore_attrs;
9191
9192   RIDBIT_RESET_ALL (specbits);
9193   if (decl_context == FUNCDEF)
9194     funcdef_flag = 1, decl_context = NORMAL;
9195   else if (decl_context == MEMFUNCDEF)
9196     funcdef_flag = -1, decl_context = FIELD;
9197   else if (decl_context == BITFIELD)
9198     bitfield = 1, decl_context = FIELD;
9199
9200   /* Look inside a declarator for the name being declared
9201      and get it as a string, for an error message.  */
9202   {
9203     tree *next = &declarator;
9204     register tree decl;
9205     name = NULL;
9206
9207     while (next && *next)
9208       {
9209         decl = *next;
9210         switch (TREE_CODE (decl))
9211           {
9212           case TREE_LIST:
9213             /* For attributes.  */
9214             next = &TREE_VALUE (decl);
9215             break;
9216
9217           case COND_EXPR:
9218             ctype = NULL_TREE;
9219             next = &TREE_OPERAND (decl, 0);
9220             break;
9221
9222           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9223             {
9224               tree name = TREE_OPERAND (decl, 0);
9225               tree rename = NULL_TREE;
9226
9227               my_friendly_assert (flags == NO_SPECIAL, 152);
9228               flags = DTOR_FLAG;
9229               return_type = return_dtor;
9230               if (TREE_CODE (name) == TYPE_DECL)
9231                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9232               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9233               if (ctype == NULL_TREE)
9234                 {
9235                   if (current_class_type == NULL_TREE)
9236                     {
9237                       error ("destructors must be member functions");
9238                       flags = NO_SPECIAL;
9239                     }
9240                   else
9241                     {
9242                       tree t = constructor_name (current_class_name);
9243                       if (t != name)
9244                         rename = t;
9245                     }
9246                 }
9247               else
9248                 {
9249                   tree t = constructor_name (ctype);
9250                   if (t != name)
9251                     rename = t;
9252                 }
9253
9254               if (rename)
9255                 {
9256                   cp_error ("destructor `%T' must match class name `%T'",
9257                             name, rename);
9258                   TREE_OPERAND (decl, 0) = rename;
9259                 }
9260               next = &name;
9261             }
9262             break;
9263
9264           case ADDR_EXPR:       /* C++ reference declaration */
9265             /* Fall through. */
9266           case ARRAY_REF:
9267           case INDIRECT_REF:
9268             ctype = NULL_TREE;
9269             innermost_code = TREE_CODE (decl);
9270             next = &TREE_OPERAND (decl, 0);
9271             break;
9272
9273           case CALL_EXPR:
9274             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9275               {
9276                 /* This is actually a variable declaration using
9277                    constructor syntax.  We need to call start_decl and
9278                    cp_finish_decl so we can get the variable
9279                    initialized...  */
9280
9281                 tree attributes, prefix_attributes;
9282
9283                 *next = TREE_OPERAND (decl, 0);
9284                 init = CALL_DECLARATOR_PARMS (decl);
9285
9286                 if (attrlist)
9287                   {
9288                     attributes = TREE_PURPOSE (attrlist);
9289                     prefix_attributes = TREE_VALUE (attrlist);
9290                   }
9291                 else
9292                   {
9293                     attributes = NULL_TREE;
9294                     prefix_attributes = NULL_TREE;
9295                   }
9296
9297                 decl = start_decl (declarator, declspecs, 1,
9298                                    attributes, prefix_attributes);
9299                 decl_type_access_control (decl);
9300                 if (decl)
9301                   {
9302                     /* Look for __unused__ attribute */
9303                     if (TREE_USED (TREE_TYPE (decl)))
9304                       TREE_USED (decl) = 1;
9305                     finish_decl (decl, init, NULL_TREE);
9306                   }
9307                 else
9308                   cp_error ("invalid declarator");
9309                 return 0;
9310               }
9311             innermost_code = TREE_CODE (decl);
9312             if (decl_context == FIELD && ctype == NULL_TREE)
9313               ctype = current_class_type;
9314             if (ctype
9315                 && TREE_OPERAND (decl, 0)
9316                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9317                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9318                          == constructor_name_full (ctype))
9319                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9320                             == constructor_name (ctype)))))
9321               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9322             next = &TREE_OPERAND (decl, 0);
9323             decl = *next;
9324             if (ctype != NULL_TREE
9325                 && decl != NULL_TREE && flags != DTOR_FLAG
9326                 && decl == constructor_name (ctype))
9327               {
9328                 return_type = return_ctor;
9329                 ctor_return_type = ctype;
9330               }
9331             ctype = NULL_TREE;
9332             break;
9333
9334           case TEMPLATE_ID_EXPR:
9335               {
9336                 tree fns = TREE_OPERAND (decl, 0);
9337
9338                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9339                   fns = TREE_OPERAND (fns, 0);
9340
9341                 dname = fns;
9342                 if (TREE_CODE (dname) == COMPONENT_REF)
9343                   dname = TREE_OPERAND (dname, 1);
9344                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9345                   {
9346                     my_friendly_assert (is_overloaded_fn (dname),
9347                                         19990331);
9348                     dname = DECL_NAME (get_first_fn (dname));
9349                   }
9350               }
9351           /* Fall through. */
9352
9353           case IDENTIFIER_NODE:
9354             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9355               dname = decl;
9356
9357             next = 0;
9358
9359             if (is_rid (dname))
9360               {
9361                 cp_error ("declarator-id missing; using reserved word `%D'",
9362                           dname);
9363                 name = IDENTIFIER_POINTER (dname);
9364               }
9365             if (! IDENTIFIER_OPNAME_P (dname)
9366                 /* GNU/Linux headers use '__op'.  Arrgh.  */
9367                 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
9368               name = IDENTIFIER_POINTER (dname);
9369             else
9370               {
9371                 if (IDENTIFIER_TYPENAME_P (dname))
9372                   {
9373                     my_friendly_assert (flags == NO_SPECIAL, 154);
9374                     flags = TYPENAME_FLAG;
9375                     ctor_return_type = TREE_TYPE (dname);
9376                     return_type = return_conversion;
9377                   }
9378                 name = operator_name_string (dname);
9379               }
9380             break;
9381
9382             /* C++ extension */
9383           case SCOPE_REF:
9384             {
9385               /* Perform error checking, and decide on a ctype.  */
9386               tree cname = TREE_OPERAND (decl, 0);
9387               if (cname == NULL_TREE)
9388                 ctype = NULL_TREE;
9389               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9390                 {
9391                   ctype = NULL_TREE;
9392                   in_namespace = TREE_OPERAND (decl, 0);
9393                   TREE_OPERAND (decl, 0) = NULL_TREE;
9394                 }
9395               else if (! is_aggr_type (cname, 1))
9396                 TREE_OPERAND (decl, 0) = NULL_TREE;
9397               /* Must test TREE_OPERAND (decl, 1), in case user gives
9398                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9399               else if (TREE_OPERAND (decl, 1)
9400                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9401                 ctype = cname;
9402               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9403                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9404                 {
9405                   cp_error ("`%T::%D' is not a valid declarator", cname,
9406                             TREE_OPERAND (decl, 1));
9407                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9408                             cname, TREE_OPERAND (decl, 1));
9409                   return void_type_node;
9410                 }
9411               else if (ctype == NULL_TREE)
9412                 ctype = cname;
9413               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9414                 TREE_OPERAND (decl, 0) = ctype;
9415               else
9416                 {
9417                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9418                     {
9419                       cp_error ("type `%T' is not derived from type `%T'",
9420                                 cname, ctype);
9421                       TREE_OPERAND (decl, 0) = NULL_TREE;
9422                     }
9423                   else
9424                     ctype = cname;
9425                 }
9426
9427               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9428                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9429                        == constructor_name_full (ctype))
9430                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9431                           == constructor_name (ctype))))
9432                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9433               next = &TREE_OPERAND (decl, 1);
9434               decl = *next;
9435               if (ctype)
9436                 {
9437                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9438                       && constructor_name (ctype) == decl)
9439                     {
9440                       return_type = return_ctor;
9441                       ctor_return_type = ctype;
9442                     }
9443                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9444                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9445                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9446                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9447                     {
9448                       return_type = return_dtor;
9449                       ctor_return_type = ctype;
9450                       flags = DTOR_FLAG;
9451                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9452                       next = &TREE_OPERAND (decl, 0);
9453                     }
9454                 }
9455             }
9456             break;
9457
9458           case ERROR_MARK:
9459             next = 0;
9460             break;
9461
9462           case TYPE_DECL:
9463             /* Parse error puts this typespec where
9464                a declarator should go.  */
9465             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9466             if (TREE_TYPE (decl) == current_class_type)
9467               cp_error ("  perhaps you want `%T' for a constructor",
9468                         current_class_name);
9469             dname = DECL_NAME (decl);
9470             name = IDENTIFIER_POINTER (dname);
9471
9472             /* Avoid giving two errors for this.  */
9473             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9474
9475             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9476             *next = dname;
9477             next = 0;
9478             break;
9479
9480           default:
9481             cp_compiler_error ("`%D' as declarator", decl);
9482             return 0; /* We used to do a 155 abort here.  */
9483           }
9484       }
9485   }
9486
9487   /* A function definition's declarator must have the form of
9488      a function declarator.  */
9489
9490   if (funcdef_flag && innermost_code != CALL_EXPR)
9491     return 0;
9492
9493   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9494       && innermost_code != CALL_EXPR
9495       && ! (ctype && declspecs == NULL_TREE))
9496     {
9497       cp_error ("declaration of `%D' as non-function", dname);
9498       return void_type_node;
9499     }
9500
9501   /* Anything declared one level down from the top level
9502      must be one of the parameters of a function
9503      (because the body is at least two levels down).  */
9504
9505   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9506      by not allowing C++ class definitions to specify their parameters
9507      with xdecls (must be spec.d in the parmlist).
9508
9509      Since we now wait to push a class scope until we are sure that
9510      we are in a legitimate method context, we must set oldcname
9511      explicitly (since current_class_name is not yet alive).
9512
9513      We also want to avoid calling this a PARM if it is in a namespace.  */
9514
9515   if (decl_context == NORMAL && !toplevel_bindings_p ())
9516     {
9517       struct binding_level *b = current_binding_level;
9518       current_binding_level = b->level_chain;
9519       if (current_binding_level != 0 && toplevel_bindings_p ())
9520         decl_context = PARM;
9521       current_binding_level = b;
9522     }
9523
9524   if (name == NULL)
9525     name = decl_context == PARM ? "parameter" : "type name";
9526
9527   /* Look through the decl specs and record which ones appear.
9528      Some typespecs are defined as built-in typenames.
9529      Others, the ones that are modifiers of other types,
9530      are represented by bits in SPECBITS: set the bits for
9531      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9532
9533      If there is a typedef name or a type, store the type in TYPE.
9534      This includes builtin typedefs such as `int'.
9535
9536      Set EXPLICIT_INT if the type is `int' or `char' and did not
9537      come from a user typedef.
9538
9539      Set LONGLONG if `long' is mentioned twice.
9540
9541      For C++, constructors and destructors have their own fast treatment.  */
9542
9543   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9544     {
9545       register int i;
9546       register tree id;
9547
9548       /* Certain parse errors slip through.  For example,
9549          `int class;' is not caught by the parser. Try
9550          weakly to recover here.  */
9551       if (TREE_CODE (spec) != TREE_LIST)
9552         return 0;
9553
9554       id = TREE_VALUE (spec);
9555
9556       if (TREE_CODE (id) == IDENTIFIER_NODE)
9557         {
9558           if (id == ridpointers[(int) RID_INT]
9559               || id == ridpointers[(int) RID_CHAR]
9560               || id == ridpointers[(int) RID_BOOL]
9561               || id == ridpointers[(int) RID_WCHAR])
9562             {
9563               if (type)
9564                 {
9565                   if (id == ridpointers[(int) RID_BOOL])
9566                     error ("`bool' is now a keyword");
9567                   else
9568                     cp_error ("extraneous `%T' ignored", id);
9569                 }
9570               else
9571                 {
9572                   if (id == ridpointers[(int) RID_INT])
9573                     explicit_int = 1;
9574                   else if (id == ridpointers[(int) RID_CHAR])
9575                     explicit_char = 1;
9576                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9577                 }
9578               goto found;
9579             }
9580           /* C++ aggregate types.  */
9581           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9582             {
9583               if (type)
9584                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9585               else
9586                 type = IDENTIFIER_TYPE_VALUE (id);
9587               goto found;
9588             }
9589
9590           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9591             {
9592               if (ridpointers[i] == id)
9593                 {
9594                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9595                     {
9596                       if (pedantic && ! in_system_header && warn_long_long)
9597                         pedwarn ("ISO C++ does not support `long long'");
9598                       if (longlong)
9599                         error ("`long long long' is too long for GCC");
9600                       else
9601                         longlong = 1;
9602                     }
9603                   else if (RIDBIT_SETP (i, specbits))
9604                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9605                   RIDBIT_SET (i, specbits);
9606                   goto found;
9607                 }
9608             }
9609         }
9610       /* C++ aggregate types.  */
9611       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9612         {
9613           if (type)
9614             cp_error ("multiple declarations `%T' and `%T'", type,
9615                       TREE_TYPE (id));
9616           else
9617             {
9618               type = TREE_TYPE (id);
9619               TREE_VALUE (spec) = type;
9620             }
9621           goto found;
9622         }
9623       if (type)
9624         error ("two or more data types in declaration of `%s'", name);
9625       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9626         {
9627           register tree t = lookup_name (id, 1);
9628           if (!t || TREE_CODE (t) != TYPE_DECL)
9629             error ("`%s' fails to be a typedef or built in type",
9630                    IDENTIFIER_POINTER (id));
9631           else
9632             {
9633               type = TREE_TYPE (t);
9634 #if 0
9635               /* See the code below that used this.  */
9636               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9637 #endif
9638               typedef_decl = t;
9639             }
9640         }
9641       else if (id != error_mark_node)
9642         /* Can't change CLASS nodes into RECORD nodes here!  */
9643         type = id;
9644
9645     found: ;
9646     }
9647
9648   typedef_type = type;
9649
9650   /* No type at all: default to `int', and set DEFAULTED_INT
9651      because it was not a user-defined typedef.  */
9652
9653   if (type == NULL_TREE
9654       && (RIDBIT_SETP (RID_SIGNED, specbits)
9655           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9656           || RIDBIT_SETP (RID_LONG, specbits)
9657           || RIDBIT_SETP (RID_SHORT, specbits)))
9658     {
9659       /* These imply 'int'.  */
9660       type = integer_type_node;
9661       defaulted_int = 1;
9662     }
9663
9664   if (type == NULL_TREE)
9665     {
9666       explicit_int = -1;
9667       if (return_type == return_dtor)
9668         type = void_type_node;
9669       else if (return_type == return_ctor)
9670         type = build_pointer_type (ctor_return_type);
9671       else if (return_type == return_conversion)
9672         type = ctor_return_type;
9673       else
9674         {
9675           /* We handle `main' specially here, because 'main () { }' is so
9676              common.  With no options, it is allowed.  With -Wreturn-type,
9677              it is a warning.  It is only an error with -pedantic-errors.  */
9678           int is_main = (funcdef_flag
9679                          && MAIN_NAME_P (dname)
9680                          && ctype == NULL_TREE
9681                          && in_namespace == NULL_TREE
9682                          && current_namespace == global_namespace);
9683
9684           if (in_system_header || flag_ms_extensions)
9685             /* Allow it, sigh.  */;
9686           else if (pedantic || ! is_main)
9687             cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
9688                         name);
9689           else if (warn_return_type)
9690             cp_warning ("ISO C++ forbids declaration of `%s' with no type",
9691                         name);
9692
9693           type = integer_type_node;
9694         }
9695     }
9696   else if (return_type == return_dtor)
9697     {
9698       error ("return type specification for destructor invalid");
9699       type = void_type_node;
9700     }
9701   else if (return_type == return_ctor)
9702     {
9703       error ("return type specification for constructor invalid");
9704       type = build_pointer_type (ctor_return_type);
9705     }
9706   else if (return_type == return_conversion)
9707     {
9708       if (!same_type_p (type, ctor_return_type))
9709         cp_error ("operator `%T' declared to return `%T'",
9710                   ctor_return_type, type);
9711       else
9712         cp_pedwarn ("return type specified for `operator %T'",
9713                     ctor_return_type);
9714
9715       type = ctor_return_type;
9716     }
9717
9718   ctype = NULL_TREE;
9719
9720   /* Now process the modifiers that were specified
9721      and check for invalid combinations.  */
9722
9723   /* Long double is a special combination.  */
9724
9725   if (RIDBIT_SETP (RID_LONG, specbits)
9726       && TYPE_MAIN_VARIANT (type) == double_type_node)
9727     {
9728       RIDBIT_RESET (RID_LONG, specbits);
9729       type = build_qualified_type (long_double_type_node,
9730                                    CP_TYPE_QUALS (type));
9731     }
9732
9733   /* Check all other uses of type modifiers.  */
9734
9735   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9736       || RIDBIT_SETP (RID_SIGNED, specbits)
9737       || RIDBIT_SETP (RID_LONG, specbits)
9738       || RIDBIT_SETP (RID_SHORT, specbits))
9739     {
9740       int ok = 0;
9741
9742       if (TREE_CODE (type) == REAL_TYPE)
9743         error ("short, signed or unsigned invalid for `%s'", name);
9744       else if (TREE_CODE (type) != INTEGER_TYPE)
9745         error ("long, short, signed or unsigned invalid for `%s'", name);
9746       else if (RIDBIT_SETP (RID_LONG, specbits)
9747                && RIDBIT_SETP (RID_SHORT, specbits))
9748         error ("long and short specified together for `%s'", name);
9749       else if ((RIDBIT_SETP (RID_LONG, specbits)
9750                 || RIDBIT_SETP (RID_SHORT, specbits))
9751                && explicit_char)
9752         error ("long or short specified with char for `%s'", name);
9753       else if ((RIDBIT_SETP (RID_LONG, specbits)
9754                 || RIDBIT_SETP (RID_SHORT, specbits))
9755                && TREE_CODE (type) == REAL_TYPE)
9756         error ("long or short specified with floating type for `%s'", name);
9757       else if (RIDBIT_SETP (RID_SIGNED, specbits)
9758                && RIDBIT_SETP (RID_UNSIGNED, specbits))
9759         error ("signed and unsigned given together for `%s'", name);
9760       else
9761         {
9762           ok = 1;
9763           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
9764             {
9765               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9766                        name);
9767               if (flag_pedantic_errors)
9768                 ok = 0;
9769             }
9770         }
9771
9772       /* Discard the type modifiers if they are invalid.  */
9773       if (! ok)
9774         {
9775           RIDBIT_RESET (RID_UNSIGNED, specbits);
9776           RIDBIT_RESET (RID_SIGNED, specbits);
9777           RIDBIT_RESET (RID_LONG, specbits);
9778           RIDBIT_RESET (RID_SHORT, specbits);
9779           longlong = 0;
9780         }
9781     }
9782
9783   if (RIDBIT_SETP (RID_COMPLEX, specbits)
9784       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9785     {
9786       error ("complex invalid for `%s'", name);
9787       RIDBIT_RESET (RID_COMPLEX, specbits);
9788     }
9789
9790   /* Decide whether an integer type is signed or not.
9791      Optionally treat bitfields as signed by default.  */
9792   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9793       /* [class.bit]
9794
9795          It is implementation-defined whether a plain (neither
9796          explicitly signed or unsigned) char, short, int, or long
9797          bit-field is signed or unsigned.
9798
9799          Naturally, we extend this to long long as well.  Note that
9800          this does not include wchar_t.  */
9801       || (bitfield && !flag_signed_bitfields
9802           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
9803           /* A typedef for plain `int' without `signed' can be
9804              controlled just like plain `int', but a typedef for
9805              `signed int' cannot be so controlled.  */
9806           && !(typedef_decl
9807                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
9808           && (TREE_CODE (type) == INTEGER_TYPE
9809               || TREE_CODE (type) == CHAR_TYPE)
9810           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
9811     {
9812       if (longlong)
9813         type = long_long_unsigned_type_node;
9814       else if (RIDBIT_SETP (RID_LONG, specbits))
9815         type = long_unsigned_type_node;
9816       else if (RIDBIT_SETP (RID_SHORT, specbits))
9817         type = short_unsigned_type_node;
9818       else if (type == char_type_node)
9819         type = unsigned_char_type_node;
9820       else if (typedef_decl)
9821         type = unsigned_type (type);
9822       else
9823         type = unsigned_type_node;
9824     }
9825   else if (RIDBIT_SETP (RID_SIGNED, specbits)
9826            && type == char_type_node)
9827     type = signed_char_type_node;
9828   else if (longlong)
9829     type = long_long_integer_type_node;
9830   else if (RIDBIT_SETP (RID_LONG, specbits))
9831     type = long_integer_type_node;
9832   else if (RIDBIT_SETP (RID_SHORT, specbits))
9833     type = short_integer_type_node;
9834
9835   if (RIDBIT_SETP (RID_COMPLEX, specbits))
9836     {
9837       /* If we just have "complex", it is equivalent to
9838          "complex double", but if any modifiers at all are specified it is
9839          the complex form of TYPE.  E.g, "complex short" is
9840          "complex short int".  */
9841
9842       if (defaulted_int && ! longlong
9843           && ! (RIDBIT_SETP (RID_LONG, specbits)
9844                 || RIDBIT_SETP (RID_SHORT, specbits)
9845                 || RIDBIT_SETP (RID_SIGNED, specbits)
9846                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
9847         type = complex_double_type_node;
9848       else if (type == integer_type_node)
9849         type = complex_integer_type_node;
9850       else if (type == float_type_node)
9851         type = complex_float_type_node;
9852       else if (type == double_type_node)
9853         type = complex_double_type_node;
9854       else if (type == long_double_type_node)
9855         type = complex_long_double_type_node;
9856       else
9857         type = build_complex_type (type);
9858     }
9859
9860   if (return_type == return_conversion
9861       && (RIDBIT_SETP (RID_CONST, specbits)
9862           || RIDBIT_SETP (RID_VOLATILE, specbits)
9863           || RIDBIT_SETP (RID_RESTRICT, specbits)))
9864     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9865               ctor_return_type);
9866
9867   /* Set CONSTP if this declaration is `const', whether by
9868      explicit specification or via a typedef.
9869      Likewise for VOLATILEP.  */
9870
9871   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
9872   restrictp =
9873     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
9874   volatilep =
9875     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
9876   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
9877                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
9878                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
9879   type = cp_build_qualified_type (type, type_quals);
9880   staticp = 0;
9881   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
9882   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
9883   RIDBIT_RESET (RID_VIRTUAL, specbits);
9884   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
9885   RIDBIT_RESET (RID_EXPLICIT, specbits);
9886
9887   if (RIDBIT_SETP (RID_STATIC, specbits))
9888     staticp = 1 + (decl_context == FIELD);
9889
9890   if (virtualp && staticp == 2)
9891     {
9892       cp_error ("member `%D' cannot be declared both virtual and static",
9893                 dname);
9894       staticp = 0;
9895     }
9896   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
9897   RIDBIT_RESET (RID_FRIEND, specbits);
9898
9899   /* Warn if two storage classes are given. Default to `auto'.  */
9900
9901   if (RIDBIT_ANY_SET (specbits))
9902     {
9903       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
9904       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
9905       if (decl_context == PARM && nclasses > 0)
9906         error ("storage class specifiers invalid in parameter declarations");
9907       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9908         {
9909           if (decl_context == PARM)
9910             error ("typedef declaration invalid in parameter declaration");
9911           nclasses++;
9912         }
9913       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
9914       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
9915     }
9916
9917   /* Give error if `virtual' is used outside of class declaration.  */
9918   if (virtualp
9919       && (current_class_name == NULL_TREE || decl_context != FIELD))
9920     {
9921       error ("virtual outside class declaration");
9922       virtualp = 0;
9923     }
9924
9925   /* Static anonymous unions are dealt with here.  */
9926   if (staticp && decl_context == TYPENAME
9927       && TREE_CODE (declspecs) == TREE_LIST
9928       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
9929     decl_context = FIELD;
9930
9931   /* Warn about storage classes that are invalid for certain
9932      kinds of declarations (parameters, typenames, etc.).  */
9933
9934   if (nclasses > 1)
9935     error ("multiple storage classes in declaration of `%s'", name);
9936   else if (decl_context != NORMAL && nclasses > 0)
9937     {
9938       if ((decl_context == PARM || decl_context == CATCHPARM)
9939           && (RIDBIT_SETP (RID_REGISTER, specbits)
9940               || RIDBIT_SETP (RID_AUTO, specbits)))
9941         ;
9942       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9943         ;
9944       else if (decl_context == FIELD
9945                /* C++ allows static class elements  */
9946                && RIDBIT_SETP (RID_STATIC, specbits))
9947         /* C++ also allows inlines and signed and unsigned elements,
9948            but in those cases we don't come in here.  */
9949         ;
9950       else
9951         {
9952           if (decl_context == FIELD)
9953             {
9954               tree tmp = NULL_TREE;
9955               register int op = 0;
9956
9957               if (declarator)
9958                 {
9959                   /* Avoid trying to get an operand off an identifier node.  */
9960                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
9961                     tmp = declarator;
9962                   else
9963                     tmp = TREE_OPERAND (declarator, 0);
9964                   op = IDENTIFIER_OPNAME_P (tmp);
9965                 }
9966               error ("storage class specified for %s `%s'",
9967                      op ? "member operator" : "field",
9968                      op ? operator_name_string (tmp) : name);
9969             }
9970           else
9971             {
9972               if (decl_context == PARM || decl_context == CATCHPARM)
9973                 error ("storage class specified for parameter `%s'", name);
9974               else
9975                 error ("storage class specified for typename");
9976             }
9977           RIDBIT_RESET (RID_REGISTER, specbits);
9978           RIDBIT_RESET (RID_AUTO, specbits);
9979           RIDBIT_RESET (RID_EXTERN, specbits);
9980         }
9981     }
9982   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
9983     {
9984       if (toplevel_bindings_p ())
9985         {
9986           /* It's common practice (and completely valid) to have a const
9987              be initialized and declared extern.  */
9988           if (!(type_quals & TYPE_QUAL_CONST))
9989             warning ("`%s' initialized and declared `extern'", name);
9990         }
9991       else
9992         error ("`%s' has both `extern' and initializer", name);
9993     }
9994   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
9995            && ! toplevel_bindings_p ())
9996     error ("nested function `%s' declared `extern'", name);
9997   else if (toplevel_bindings_p ())
9998     {
9999       if (RIDBIT_SETP (RID_AUTO, specbits))
10000         error ("top-level declaration of `%s' specifies `auto'", name);
10001     }
10002
10003   if (nclasses > 0 && friendp)
10004     error ("storage class specifiers invalid in friend function declarations");
10005
10006   /* Now figure out the structure of the declarator proper.
10007      Descend through it, creating more complex types, until we reach
10008      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10009
10010   inner_attrs = NULL_TREE;
10011   ignore_attrs = 0;
10012
10013   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10014          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10015     {
10016       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10017          an INDIRECT_REF (for *...),
10018          a CALL_EXPR (for ...(...)),
10019          an identifier (for the name being declared)
10020          or a null pointer (for the place in an absolute declarator
10021          where the name was omitted).
10022          For the last two cases, we have just exited the loop.
10023
10024          For C++ it could also be
10025          a SCOPE_REF (for class :: ...).  In this case, we have converted
10026          sensible names to types, and those are the values we use to
10027          qualify the member name.
10028          an ADDR_EXPR (for &...),
10029          a BIT_NOT_EXPR (for destructors)
10030
10031          At this point, TYPE is the type of elements of an array,
10032          or for a function to return, or for a pointer to point to.
10033          After this sequence of ifs, TYPE is the type of the
10034          array or function or pointer, and DECLARATOR has had its
10035          outermost layer removed.  */
10036
10037       if (type == error_mark_node)
10038         {
10039           if (TREE_CODE (declarator) == SCOPE_REF)
10040             declarator = TREE_OPERAND (declarator, 1);
10041           else
10042             declarator = TREE_OPERAND (declarator, 0);
10043           continue;
10044         }
10045       if (quals != NULL_TREE
10046           && (declarator == NULL_TREE
10047               || TREE_CODE (declarator) != SCOPE_REF))
10048         {
10049           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10050             ctype = TYPE_METHOD_BASETYPE (type);
10051           if (ctype != NULL_TREE)
10052             {
10053               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10054               grok_method_quals (ctype, dummy, quals);
10055               type = TREE_TYPE (dummy);
10056               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10057               quals = NULL_TREE;
10058             }
10059         }
10060
10061       /* See the comment for the TREE_LIST case, below.  */
10062       if (ignore_attrs)
10063         ignore_attrs = 0;
10064       else if (inner_attrs)
10065         {
10066           decl_attributes (type, inner_attrs, NULL_TREE);
10067           inner_attrs = NULL_TREE;
10068         }
10069
10070       switch (TREE_CODE (declarator))
10071         {
10072         case TREE_LIST:
10073           {
10074             /* We encode a declarator with embedded attributes using
10075                a TREE_LIST.  The attributes apply to the declarator
10076                directly inside them, so we have to skip an iteration
10077                before applying them to the type.  If the declarator just
10078                inside is the declarator-id, we apply the attrs to the
10079                decl itself.  */
10080             inner_attrs = TREE_PURPOSE (declarator);
10081             ignore_attrs = 1;
10082             declarator = TREE_VALUE (declarator);
10083           }
10084           break;
10085
10086         case ARRAY_REF:
10087           {
10088             register tree size;
10089
10090             size = TREE_OPERAND (declarator, 1);
10091
10092             /* VC++ spells a zero-sized array with [].  */
10093             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10094                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10095               size = integer_zero_node;
10096
10097             declarator = TREE_OPERAND (declarator, 0);
10098
10099             type = create_array_type_for_decl (dname, type, size);
10100             ctype = NULL_TREE;
10101           }
10102           break;
10103
10104         case CALL_EXPR:
10105           {
10106             tree arg_types;
10107             int funcdecl_p;
10108             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10109             tree inner_decl = TREE_OPERAND (declarator, 0);
10110
10111             /* Declaring a function type.
10112                Make sure we have a valid type for the function to return.  */
10113
10114             /* We now know that the TYPE_QUALS don't apply to the
10115                decl, but to its return type.  */
10116             type_quals = TYPE_UNQUALIFIED;
10117
10118             /* Warn about some types functions can't return.  */
10119
10120             if (TREE_CODE (type) == FUNCTION_TYPE)
10121               {
10122                 error ("`%s' declared as function returning a function", name);
10123                 type = integer_type_node;
10124               }
10125             if (TREE_CODE (type) == ARRAY_TYPE)
10126               {
10127                 error ("`%s' declared as function returning an array", name);
10128                 type = integer_type_node;
10129               }
10130
10131             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10132               inner_decl = TREE_OPERAND (inner_decl, 1);
10133
10134             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10135               inner_decl = dname;
10136
10137             /* Pick up type qualifiers which should be applied to `this'.  */
10138             quals = CALL_DECLARATOR_QUALS (declarator);
10139
10140             /* Pick up the exception specifications.  */
10141             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10142
10143             /* Say it's a definition only for the CALL_EXPR
10144                closest to the identifier.  */
10145             funcdecl_p
10146               = inner_decl
10147               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10148                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10149                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10150
10151             if (ctype == NULL_TREE
10152                 && decl_context == FIELD
10153                 && funcdecl_p
10154                 && (friendp == 0 || dname == current_class_name))
10155               ctype = current_class_type;
10156
10157             if (ctype && return_type == return_conversion)
10158               TYPE_HAS_CONVERSION (ctype) = 1;
10159             if (ctype && constructor_name (ctype) == dname)
10160               {
10161                 /* We are within a class's scope. If our declarator name
10162                    is the same as the class name, and we are defining
10163                    a function, then it is a constructor/destructor, and
10164                    therefore returns a void type.  */
10165
10166                 if (flags == DTOR_FLAG)
10167                   {
10168                     /* ISO C++ 12.4/2.  A destructor may not be
10169                        declared const or volatile.  A destructor may
10170                        not be static.  */
10171                     if (staticp == 2)
10172                       error ("destructor cannot be static member function");
10173                     if (quals)
10174                       {
10175                         cp_error ("destructors may not be `%s'",
10176                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10177                         quals = NULL_TREE;
10178                       }
10179                     if (decl_context == FIELD)
10180                       {
10181                         if (! member_function_or_else (ctype,
10182                                                        current_class_type,
10183                                                        flags))
10184                           return void_type_node;
10185                       }
10186                   }
10187                 else            /* It's a constructor.  */
10188                   {
10189                     if (explicitp == 1)
10190                       explicitp = 2;
10191                     /* ISO C++ 12.1.  A constructor may not be
10192                        declared const or volatile.  A constructor may
10193                        not be virtual.  A constructor may not be
10194                        static.  */
10195                     if (staticp == 2)
10196                       error ("constructor cannot be static member function");
10197                     if (virtualp)
10198                       {
10199                         pedwarn ("constructors cannot be declared virtual");
10200                         virtualp = 0;
10201                       }
10202                     if (quals)
10203                       {
10204                         cp_error ("constructors may not be `%s'",
10205                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10206                         quals = NULL_TREE;
10207                       }
10208                     {
10209                       RID_BIT_TYPE tmp_bits;
10210                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10211                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10212                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10213                       if (RIDBIT_ANY_SET (tmp_bits))
10214                         error ("return value type specifier for constructor ignored");
10215                     }
10216                     type = build_pointer_type (ctype);
10217                     if (decl_context == FIELD)
10218                       {
10219                         if (! member_function_or_else (ctype,
10220                                                        current_class_type,
10221                                                        flags))
10222                           return void_type_node;
10223                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10224                         if (return_type != return_ctor)
10225                           return NULL_TREE;
10226                       }
10227                   }
10228                 if (decl_context == FIELD)
10229                   staticp = 0;
10230               }
10231             else if (friendp)
10232               {
10233                 if (initialized)
10234                   error ("can't initialize friend function `%s'", name);
10235                 if (virtualp)
10236                   {
10237                     /* Cannot be both friend and virtual.  */
10238                     error ("virtual functions cannot be friends");
10239                     RIDBIT_RESET (RID_FRIEND, specbits);
10240                     friendp = 0;
10241                   }
10242                 if (decl_context == NORMAL)
10243                   error ("friend declaration not in class definition");
10244                 if (current_function_decl && funcdef_flag)
10245                   cp_error ("can't define friend function `%s' in a local class definition",
10246                             name);
10247               }
10248
10249             /* Construct the function type and go to the next
10250                inner layer of declarator.  */
10251
10252             declarator = TREE_OPERAND (declarator, 0);
10253
10254             /* FIXME: This is where default args should be fully
10255                processed.  */
10256
10257             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10258
10259             if (declarator && flags == DTOR_FLAG)
10260               {
10261                 /* A destructor declared in the body of a class will
10262                    be represented as a BIT_NOT_EXPR.  But, we just
10263                    want the underlying IDENTIFIER.  */
10264                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10265                   declarator = TREE_OPERAND (declarator, 0);
10266
10267                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10268                   arg_types = void_list_node;
10269                 else if (arg_types == NULL_TREE
10270                          || arg_types != void_list_node)
10271                   {
10272                     cp_error ("destructors may not have parameters");
10273                     arg_types = void_list_node;
10274                     last_function_parms = NULL_TREE;
10275                   }
10276               }
10277
10278             /* ANSI says that `const int foo ();'
10279                does not make the function foo const.  */
10280             type = build_function_type (type, arg_types);
10281
10282             {
10283               tree t;
10284               for (t = arg_types; t; t = TREE_CHAIN (t))
10285                 if (TREE_PURPOSE (t)
10286                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10287                   {
10288                     add_defarg_fn (type);
10289                     break;
10290                   }
10291             }
10292           }
10293           break;
10294
10295         case ADDR_EXPR:
10296         case INDIRECT_REF:
10297           /* Filter out pointers-to-references and references-to-references.
10298              We can get these if a TYPE_DECL is used.  */
10299
10300           if (TREE_CODE (type) == REFERENCE_TYPE)
10301             {
10302               error ("cannot declare %s to references",
10303                      TREE_CODE (declarator) == ADDR_EXPR
10304                      ? "references" : "pointers");
10305               declarator = TREE_OPERAND (declarator, 0);
10306               continue;
10307             }
10308
10309           if (TREE_CODE (type) == OFFSET_TYPE
10310               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10311                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10312             {
10313               cp_error ("cannot declare pointer to `%#T' member",
10314                         TREE_TYPE (type));
10315               type = TREE_TYPE (type);
10316             }
10317
10318           /* Merge any constancy or volatility into the target type
10319              for the pointer.  */
10320
10321           /* We now know that the TYPE_QUALS don't apply to the decl,
10322              but to the target of the pointer.  */
10323           type_quals = TYPE_UNQUALIFIED;
10324
10325           if (TREE_CODE (declarator) == ADDR_EXPR)
10326             {
10327               if (TREE_CODE (type) == VOID_TYPE)
10328                 error ("invalid type: `void &'");
10329               else
10330                 type = build_reference_type (type);
10331             }
10332           else if (TREE_CODE (type) == METHOD_TYPE)
10333             type = build_ptrmemfunc_type (build_pointer_type (type));
10334           else
10335             type = build_pointer_type (type);
10336
10337           /* Process a list of type modifier keywords (such as
10338              const or volatile) that were given inside the `*' or `&'.  */
10339
10340           if (TREE_TYPE (declarator))
10341             {
10342               register tree typemodlist;
10343               int erred = 0;
10344
10345               constp = 0;
10346               volatilep = 0;
10347               restrictp = 0;
10348               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10349                    typemodlist = TREE_CHAIN (typemodlist))
10350                 {
10351                   tree qualifier = TREE_VALUE (typemodlist);
10352
10353                   if (qualifier == ridpointers[(int) RID_CONST])
10354                     constp++;
10355                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10356                     volatilep++;
10357                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10358                     restrictp++;
10359                   else if (!erred)
10360                     {
10361                       erred = 1;
10362                       error ("invalid type modifier within pointer declarator");
10363                     }
10364                 }
10365               if (constp > 1)
10366                 pedwarn ("duplicate `const'");
10367               if (volatilep > 1)
10368                 pedwarn ("duplicate `volatile'");
10369               if (restrictp > 1)
10370                 pedwarn ("duplicate `restrict'");
10371
10372               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10373                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10374                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10375               if (TREE_CODE (declarator) == ADDR_EXPR
10376                   && (constp || volatilep))
10377                 {
10378                   if (constp)
10379                     pedwarn ("discarding `const' applied to a reference");
10380                   if (volatilep)
10381                     pedwarn ("discarding `volatile' applied to a reference");
10382                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10383                 }
10384               type = cp_build_qualified_type (type, type_quals);
10385             }
10386           declarator = TREE_OPERAND (declarator, 0);
10387           ctype = NULL_TREE;
10388           break;
10389
10390         case SCOPE_REF:
10391           {
10392             /* We have converted type names to NULL_TREE if the
10393                name was bogus, or to a _TYPE node, if not.
10394
10395                The variable CTYPE holds the type we will ultimately
10396                resolve to.  The code here just needs to build
10397                up appropriate member types.  */
10398             tree sname = TREE_OPERAND (declarator, 1);
10399             tree t;
10400
10401             /* Destructors can have their visibilities changed as well.  */
10402             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10403               sname = TREE_OPERAND (sname, 0);
10404
10405             if (TREE_COMPLEXITY (declarator) == 0)
10406               /* This needs to be here, in case we are called
10407                  multiple times.  */ ;
10408             else if (TREE_COMPLEXITY (declarator) == -1)
10409               /* Namespace member. */
10410               pop_decl_namespace ();
10411             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10412               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10413             else if (! IS_AGGR_TYPE_CODE
10414                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10415               ;
10416             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10417               {
10418                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10419                    that refer to ctype.  They couldn't be resolved earlier
10420                    because we hadn't pushed into the class yet.
10421                    Example: resolve 'B<T>::type' in
10422                    'B<typename B<T>::type> B<T>::f () { }'.  */
10423                 if (current_template_parms
10424                     && uses_template_parms (type)
10425                     && uses_template_parms (current_class_type))
10426                   {
10427                     tree args = current_template_args ();
10428                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10429                   }
10430
10431                 /* This pop_nested_class corresponds to the
10432                    push_nested_class used to push into class scope for
10433                    parsing the argument list of a function decl, in
10434                    qualified_id.  */
10435                 pop_nested_class ();
10436                 TREE_COMPLEXITY (declarator) = current_class_depth;
10437               }
10438             else
10439               my_friendly_abort (16);
10440
10441             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10442               {
10443                 /* We had a reference to a global decl, or
10444                    perhaps we were given a non-aggregate typedef,
10445                    in which case we cleared this out, and should just
10446                    keep going as though it wasn't there.  */
10447                 declarator = sname;
10448                 continue;
10449               }
10450             ctype = TREE_OPERAND (declarator, 0);
10451
10452             t = ctype;
10453             while (t != NULL_TREE && CLASS_TYPE_P (t))
10454               {
10455                 if (CLASSTYPE_TEMPLATE_INFO (t) &&
10456                     !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
10457                   template_count += 1;
10458                 t = TYPE_MAIN_DECL (t);
10459                 if (DECL_LANG_SPECIFIC (t))
10460                   t = DECL_CONTEXT (t);
10461                 else
10462                   t = NULL_TREE;
10463               }
10464
10465             if (sname == NULL_TREE)
10466               goto done_scoping;
10467
10468             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10469               {
10470                 /* This is the `standard' use of the scoping operator:
10471                    basetype :: member .  */
10472
10473                 if (ctype == current_class_type)
10474                   {
10475                     /* class A {
10476                          void A::f ();
10477                        };
10478
10479                        Is this ill-formed?  */
10480
10481                     if (pedantic)
10482                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10483                                   ctype, name);
10484                   }
10485                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10486                   {
10487                     if (current_class_type == NULL_TREE
10488                         || friendp)
10489                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10490                                                       TYPE_ARG_TYPES (type));
10491                     else
10492                       {
10493                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10494                                   ctype, name, current_class_type);
10495                         return void_type_node;
10496                       }
10497                   }
10498                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10499                          || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
10500                   {
10501                     /* Have to move this code elsewhere in this function.
10502                        this code is used for i.e., typedef int A::M; M *pm;
10503
10504                        It is?  How? jason 10/2/94 */
10505
10506                     if (current_class_type)
10507                       {
10508                         cp_error ("cannot declare member `%T::%s' within `%T'",
10509                                   ctype, name, current_class_type);
10510                         return void_type_node;
10511                       }
10512                     type = build_offset_type (ctype, type);
10513                   }
10514                 else if (uses_template_parms (ctype))
10515                   {
10516                     if (TREE_CODE (type) == FUNCTION_TYPE)
10517                       type
10518                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10519                                                    TYPE_ARG_TYPES (type));
10520                   }
10521                 else
10522                   {
10523                     cp_error ("structure `%T' not yet defined", ctype);
10524                     return error_mark_node;
10525                   }
10526
10527                 declarator = sname;
10528               }
10529             else if (TREE_CODE (sname) == SCOPE_REF)
10530               my_friendly_abort (17);
10531             else
10532               {
10533               done_scoping:
10534                 declarator = TREE_OPERAND (declarator, 1);
10535                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10536                   /* In this case, we will deal with it later.  */
10537                   ;
10538                 else
10539                   {
10540                     if (TREE_CODE (type) == FUNCTION_TYPE)
10541                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10542                                                       TYPE_ARG_TYPES (type));
10543                     else
10544                       type = build_offset_type (ctype, type);
10545                   }
10546               }
10547           }
10548           break;
10549
10550         case BIT_NOT_EXPR:
10551           declarator = TREE_OPERAND (declarator, 0);
10552           break;
10553
10554         case RECORD_TYPE:
10555         case UNION_TYPE:
10556         case ENUMERAL_TYPE:
10557           declarator = NULL_TREE;
10558           break;
10559
10560         case ERROR_MARK:
10561           declarator = NULL_TREE;
10562           break;
10563
10564         default:
10565           my_friendly_abort (158);
10566         }
10567     }
10568
10569   /* See the comment for the TREE_LIST case, above.  */
10570   if (inner_attrs)
10571     {
10572       if (! ignore_attrs)
10573         decl_attributes (type, inner_attrs, NULL_TREE);
10574       else if (attrlist)
10575         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10576       else
10577         attrlist = build_decl_list (NULL_TREE, inner_attrs);
10578     }
10579
10580   /* Now TYPE has the actual type.  */
10581
10582   if (explicitp == 1 || (explicitp && friendp))
10583     {
10584       /* [dcl.fct.spec] The explicit specifier shall only be used in
10585          declarations of constructors within a class definition.  */
10586       error ("only declarations of constructors can be `explicit'");
10587       explicitp = 0;
10588     }
10589
10590   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10591     {
10592       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10593         {
10594           error ("non-member `%s' cannot be declared `mutable'", name);
10595           RIDBIT_RESET (RID_MUTABLE, specbits);
10596         }
10597       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10598         {
10599           error ("non-object member `%s' cannot be declared `mutable'", name);
10600           RIDBIT_RESET (RID_MUTABLE, specbits);
10601         }
10602       else if (TREE_CODE (type) == FUNCTION_TYPE
10603                || TREE_CODE (type) == METHOD_TYPE)
10604         {
10605           error ("function `%s' cannot be declared `mutable'", name);
10606           RIDBIT_RESET (RID_MUTABLE, specbits);
10607         }
10608       else if (staticp)
10609         {
10610           error ("static `%s' cannot be declared `mutable'", name);
10611           RIDBIT_RESET (RID_MUTABLE, specbits);
10612         }
10613       else if (type_quals & TYPE_QUAL_CONST)
10614         {
10615           error ("const `%s' cannot be declared `mutable'", name);
10616           RIDBIT_RESET (RID_MUTABLE, specbits);
10617         }
10618     }
10619
10620   if (declarator == NULL_TREE
10621       || TREE_CODE (declarator) == IDENTIFIER_NODE
10622       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10623           && (TREE_CODE (type) == FUNCTION_TYPE
10624               || TREE_CODE (type) == METHOD_TYPE)))
10625     /* OK */;
10626   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10627     {
10628       cp_error ("template-id `%D' used as a declarator", declarator);
10629       declarator = dname;
10630     }
10631   else
10632     /* Unexpected declarator format.  */
10633     my_friendly_abort (990210);
10634
10635   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10636
10637   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10638     {
10639       tree decl;
10640
10641       /* Note that the grammar rejects storage classes
10642          in typenames, fields or parameters.  */
10643       if (current_lang_name == lang_name_java)
10644         TYPE_FOR_JAVA (type) = 1;
10645
10646       if (decl_context == FIELD)
10647         {
10648           if (declarator == constructor_name (current_class_type))
10649             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10650                         declarator);
10651           decl = build_lang_decl (TYPE_DECL, declarator, type);
10652         }
10653       else
10654         {
10655           /* Make sure this typedef lives as long as its type,
10656              since it might be used as a template parameter. */
10657           if (processing_template_decl)
10658             decl = build_lang_decl (TYPE_DECL, declarator, type);
10659           else
10660             decl = build_decl (TYPE_DECL, declarator, type);
10661         }
10662
10663       /* If the user declares "typedef struct {...} foo" then the
10664          struct will have an anonymous name.  Fill that name in now.
10665          Nothing can refer to it, so nothing needs know about the name
10666          change.  */
10667       if (type != error_mark_node
10668           && TYPE_NAME (type)
10669           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10670           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10671           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10672         {
10673           tree oldname = TYPE_NAME (type);
10674           tree t;
10675
10676           /* Replace the anonymous name with the real name everywhere.  */
10677           lookup_tag_reverse (type, declarator);
10678           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10679             if (TYPE_NAME (t) == oldname)
10680               TYPE_NAME (t) = decl;
10681
10682           if (TYPE_LANG_SPECIFIC (type))
10683             TYPE_WAS_ANONYMOUS (type) = 1;
10684
10685           /* If this is a typedef within a template class, the nested
10686              type is a (non-primary) template.  The name for the
10687              template needs updating as well.  */
10688           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10689             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10690               = TYPE_IDENTIFIER (type);
10691
10692           /* XXX Temporarily set the scope.
10693              When returning, start_decl expects it as NULL_TREE,
10694              and will then then set it using pushdecl. */
10695           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10696           if (current_class_type)
10697             DECL_CONTEXT (decl) = current_class_type;
10698           else
10699             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10700
10701           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10702           DECL_ASSEMBLER_NAME (decl)
10703             = get_identifier (build_overload_name (type, 1, 1));
10704           DECL_CONTEXT (decl) = NULL_TREE;
10705
10706           /* FIXME remangle member functions; member functions of a
10707              type with external linkage have external linkage.  */
10708         }
10709
10710       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10711         {
10712           cp_error_at ("typedef name may not be class-qualified", decl);
10713           return NULL_TREE;
10714         }
10715       else if (quals)
10716         {
10717           if (ctype == NULL_TREE)
10718             {
10719               if (TREE_CODE (type) != METHOD_TYPE)
10720                 cp_error_at ("invalid type qualifier for non-member function type", decl);
10721               else
10722                 ctype = TYPE_METHOD_BASETYPE (type);
10723             }
10724           if (ctype != NULL_TREE)
10725             grok_method_quals (ctype, decl, quals);
10726         }
10727
10728       if (RIDBIT_SETP (RID_SIGNED, specbits)
10729           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10730         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10731
10732       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
10733                       inlinep, friendp, raises != NULL_TREE);
10734
10735       if (initialized)
10736         error ("typedef declaration includes an initializer");
10737
10738       return decl;
10739     }
10740
10741   /* Detect the case of an array type of unspecified size
10742      which came, as such, direct from a typedef name.
10743      We must copy the type, so that each identifier gets
10744      a distinct type, so that each identifier's size can be
10745      controlled separately by its own initializer.  */
10746
10747   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
10748       && TYPE_DOMAIN (type) == NULL_TREE)
10749     {
10750       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
10751     }
10752
10753   /* If this is a type name (such as, in a cast or sizeof),
10754      compute the type and return it now.  */
10755
10756   if (decl_context == TYPENAME)
10757     {
10758       /* Note that the grammar rejects storage classes
10759          in typenames, fields or parameters.  */
10760       if (type_quals != TYPE_UNQUALIFIED)
10761         type_quals = TYPE_UNQUALIFIED;
10762
10763       /* Special case: "friend class foo" looks like a TYPENAME context.  */
10764       if (friendp)
10765         {
10766           if (type_quals != TYPE_UNQUALIFIED)
10767             {
10768               cp_error ("type qualifiers specified for friend class declaration");
10769               type_quals = TYPE_UNQUALIFIED;
10770             }
10771           if (inlinep)
10772             {
10773               cp_error ("`inline' specified for friend class declaration");
10774               inlinep = 0;
10775             }
10776
10777           /* Only try to do this stuff if we didn't already give up.  */
10778           if (type != integer_type_node)
10779             {
10780               /* A friendly class?  */
10781               if (current_class_type)
10782                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
10783               else
10784                 error ("trying to make class `%s' a friend of global scope",
10785                        TYPE_NAME_STRING (type));
10786               type = void_type_node;
10787             }
10788         }
10789       else if (quals)
10790         {
10791           if (ctype == NULL_TREE)
10792             {
10793               if (TREE_CODE (type) != METHOD_TYPE)
10794                 cp_error ("invalid qualifiers on non-member function type");
10795               else
10796                 ctype = TYPE_METHOD_BASETYPE (type);
10797             }
10798           if (ctype)
10799             {
10800               tree dummy = build_decl (TYPE_DECL, declarator, type);
10801               grok_method_quals (ctype, dummy, quals);
10802               type = TREE_TYPE (dummy);
10803             }
10804         }
10805
10806       return type;
10807     }
10808   else if (declarator == NULL_TREE && decl_context != PARM
10809            && decl_context != CATCHPARM
10810            && TREE_CODE (type) != UNION_TYPE
10811            && ! bitfield)
10812     {
10813       cp_error ("abstract declarator `%T' used as declaration", type);
10814       declarator = make_anon_name ();
10815     }
10816
10817   /* `void' at top level (not within pointer)
10818      is allowed only in typedefs or type names.
10819      We don't complain about parms either, but that is because
10820      a better error message can be made later.  */
10821
10822   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
10823     {
10824       if (! declarator)
10825         error ("unnamed variable or field declared void");
10826       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10827         {
10828           if (IDENTIFIER_OPNAME_P (declarator))
10829             my_friendly_abort (356);
10830           else
10831             error ("variable or field `%s' declared void", name);
10832         }
10833       else
10834         error ("variable or field declared void");
10835       type = integer_type_node;
10836     }
10837
10838   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10839      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
10840
10841   if (decl_context == PARM || decl_context == CATCHPARM)
10842     {
10843       if (ctype || in_namespace)
10844         error ("cannot use `::' in parameter declaration");
10845
10846       /* A parameter declared as an array of T is really a pointer to T.
10847          One declared as a function is really a pointer to a function.
10848          One declared as a member is really a pointer to member.  */
10849
10850       if (TREE_CODE (type) == ARRAY_TYPE)
10851         {
10852           /* Transfer const-ness of array into that of type pointed to.  */
10853           type = build_pointer_type (TREE_TYPE (type));
10854           type_quals = TYPE_UNQUALIFIED;
10855         }
10856       else if (TREE_CODE (type) == FUNCTION_TYPE)
10857         type = build_pointer_type (type);
10858       else if (TREE_CODE (type) == OFFSET_TYPE)
10859         type = build_pointer_type (type);
10860       else if (TREE_CODE (type) == VOID_TYPE && declarator)
10861         {
10862           error ("declaration of `%s' as void", name);
10863           return NULL_TREE;
10864         }
10865     }
10866
10867   {
10868     register tree decl;
10869
10870     if (decl_context == PARM)
10871       {
10872         decl = build_decl (PARM_DECL, declarator, type);
10873
10874         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
10875                         inlinep, friendp, raises != NULL_TREE);
10876
10877         /* Compute the type actually passed in the parmlist,
10878            for the case where there is no prototype.
10879            (For example, shorts and chars are passed as ints.)
10880            When there is a prototype, this is overridden later.  */
10881
10882         DECL_ARG_TYPE (decl) = type_promotes_to (type);
10883       }
10884     else if (decl_context == FIELD)
10885       {
10886         if (type == error_mark_node)
10887           {
10888             /* Happens when declaring arrays of sizes which
10889                are error_mark_node, for example.  */
10890             decl = NULL_TREE;
10891           }
10892         else if (in_namespace && !friendp)
10893           {
10894             /* Something like struct S { int N::j; };  */
10895             cp_error ("invalid use of `::'");
10896             decl = NULL_TREE;
10897           }
10898         else if (TREE_CODE (type) == FUNCTION_TYPE)
10899           {
10900             int publicp = 0;
10901             tree function_context;
10902
10903             /* We catch the others as conflicts with the builtin
10904                typedefs.  */
10905             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
10906               {
10907                 cp_error ("function `%D' cannot be declared friend",
10908                           declarator);
10909                 friendp = 0;
10910               }
10911
10912             if (friendp == 0)
10913               {
10914                 if (ctype == NULL_TREE)
10915                   ctype = current_class_type;
10916
10917                 if (ctype == NULL_TREE)
10918                   {
10919                     cp_error ("can't make `%D' into a method -- not in a class",
10920                               declarator);
10921                     return void_type_node;
10922                   }
10923
10924                 /* ``A union may [ ... ] not [ have ] virtual functions.''
10925                    ARM 9.5 */
10926                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
10927                   {
10928                     cp_error ("function `%D' declared virtual inside a union",
10929                               declarator);
10930                     return void_type_node;
10931                   }
10932
10933                 if (declarator == ansi_opname[(int) NEW_EXPR]
10934                     || declarator == ansi_opname[(int) VEC_NEW_EXPR]
10935                     || declarator == ansi_opname[(int) DELETE_EXPR]
10936                     || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
10937                   {
10938                     if (virtualp)
10939                       {
10940                         cp_error ("`%D' cannot be declared virtual, since it is always static",
10941                                   declarator);
10942                         virtualp = 0;
10943                       }
10944                   }
10945                 else if (staticp < 2)
10946                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
10947                                                   TYPE_ARG_TYPES (type));
10948               }
10949
10950             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
10951             function_context = (ctype != NULL_TREE) ?
10952               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
10953             publicp = (! friendp || ! staticp)
10954               && function_context == NULL_TREE;
10955             decl = grokfndecl (ctype, type,
10956                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
10957                                ? declarator : dname,
10958                                declarator,
10959                                virtualp, flags, quals, raises,
10960                                friendp ? -1 : 0, friendp, publicp, inlinep,
10961                                funcdef_flag, template_count, in_namespace);
10962             if (decl == NULL_TREE)
10963               return decl;
10964 #if 0
10965             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
10966             /* The decl and setting of decl_machine_attr is also turned off.  */
10967             decl = build_decl_attribute_variant (decl, decl_machine_attr);
10968 #endif
10969
10970             /* [class.conv.ctor]
10971
10972                A constructor declared without the function-specifier
10973                explicit that can be called with a single parameter
10974                specifies a conversion from the type of its first
10975                parameter to the type of its class.  Such a constructor
10976                is called a converting constructor.  */
10977             if (explicitp == 2)
10978               DECL_NONCONVERTING_P (decl) = 1;
10979             else if (DECL_CONSTRUCTOR_P (decl))
10980               {
10981                 /* The constructor can be called with exactly one
10982                    parameter if there is at least one parameter, and
10983                    any subsequent parameters have default arguments.
10984                    We don't look at the first parameter, which is
10985                    really just the `this' parameter for the new
10986                    object.  */
10987                 tree arg_types =
10988                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
10989
10990                 /* Skip the `in_chrg' argument too, if present.  */
10991                 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl)))
10992                   arg_types = TREE_CHAIN (arg_types);
10993
10994                 if (arg_types == void_list_node
10995                     || (arg_types
10996                         && TREE_CHAIN (arg_types)
10997                         && TREE_CHAIN (arg_types) != void_list_node
10998                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
10999                   DECL_NONCONVERTING_P (decl) = 1;
11000               }
11001           }
11002         else if (TREE_CODE (type) == METHOD_TYPE)
11003           {
11004             /* We only get here for friend declarations of
11005                members of other classes.  */
11006             /* All method decls are public, so tell grokfndecl to set
11007                TREE_PUBLIC, also.  */
11008             decl = grokfndecl (ctype, type, declarator, declarator,
11009                                virtualp, flags, quals, raises,
11010                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11011                                template_count, in_namespace);
11012             if (decl == NULL_TREE)
11013               return NULL_TREE;
11014           }
11015         else if (!staticp && ! processing_template_decl
11016                  && TYPE_SIZE (complete_type (type)) == NULL_TREE
11017                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11018           {
11019             if (declarator)
11020               cp_error ("field `%D' has incomplete type", declarator);
11021             else
11022               cp_error ("name `%T' has incomplete type", type);
11023
11024             /* If we're instantiating a template, tell them which
11025                instantiation made the field's type be incomplete.  */
11026             if (current_class_type
11027                 && TYPE_NAME (current_class_type)
11028                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11029                 && declspecs && TREE_VALUE (declspecs)
11030                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11031               cp_error ("  in instantiation of template `%T'",
11032                         current_class_type);
11033
11034             type = error_mark_node;
11035             decl = NULL_TREE;
11036           }
11037         else
11038           {
11039             if (friendp)
11040               {
11041                 error ("`%s' is neither function nor member function; cannot be declared friend",
11042                        IDENTIFIER_POINTER (declarator));
11043                 friendp = 0;
11044               }
11045             decl = NULL_TREE;
11046           }
11047
11048         if (friendp)
11049           {
11050             /* Friends are treated specially.  */
11051             if (ctype == current_class_type)
11052               warning ("member functions are implicitly friends of their class");
11053             else
11054               {
11055                 tree t = NULL_TREE;
11056                 if (decl && DECL_NAME (decl))
11057                   {
11058                     if (template_class_depth (current_class_type) == 0)
11059                       {
11060                         decl
11061                           = check_explicit_specialization
11062                           (declarator, decl,
11063                            template_count, 2 * (funcdef_flag != 0) + 4);
11064                         if (decl == error_mark_node)
11065                           return error_mark_node;
11066                       }
11067
11068                     t = do_friend (ctype, declarator, decl,
11069                                    last_function_parms, attrlist, flags, quals,
11070                                    funcdef_flag);
11071                   }
11072                 if (t && funcdef_flag)
11073                   return t;
11074
11075                 return void_type_node;
11076               }
11077           }
11078
11079         /* Structure field.  It may not be a function, except for C++ */
11080
11081         if (decl == NULL_TREE)
11082           {
11083             if (initialized)
11084               {
11085                 if (!staticp)
11086                   {
11087                     /* An attempt is being made to initialize a non-static
11088                        member.  But, from [class.mem]:
11089
11090                        4 A member-declarator can contain a
11091                        constant-initializer only if it declares a static
11092                        member (_class.static_) of integral or enumeration
11093                        type, see _class.static.data_.
11094
11095                        This used to be relatively common practice, but
11096                        the rest of the compiler does not correctly
11097                        handle the initialization unless the member is
11098                        static so we make it static below.  */
11099                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11100                                 declarator);
11101                     cp_pedwarn ("making `%D' static", declarator);
11102                     staticp = 1;
11103                   }
11104
11105                 if (uses_template_parms (type))
11106                   /* We'll check at instantiation time.  */
11107                   ;
11108                 else if (check_static_variable_definition (declarator,
11109                                                            type))
11110                   /* If we just return the declaration, crashes
11111                      will sometimes occur.  We therefore return
11112                      void_type_node, as if this was a friend
11113                      declaration, to cause callers to completely
11114                      ignore this declaration.  */
11115                   return void_type_node;
11116               }
11117
11118             /* 9.2p13 [class.mem] */
11119             if (declarator == constructor_name (current_class_type)
11120                 /* Divergence from the standard:  In extern "C", we
11121                    allow non-static data members here, because C does
11122                    and /usr/include/netinet/in.h uses that.  */
11123                 && (staticp || ! in_system_header))
11124               cp_pedwarn ("ISO C++ forbids data member `%D' with same name as enclosing class",
11125                           declarator);
11126
11127             if (staticp)
11128               {
11129                 /* C++ allows static class members.  All other work
11130                    for this is done by grokfield.  */
11131                 decl = build_lang_decl (VAR_DECL, declarator, type);
11132                 TREE_STATIC (decl) = 1;
11133                 /* In class context, 'static' means public access.  */
11134                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11135               }
11136             else
11137               {
11138                 decl = build_lang_decl (FIELD_DECL, declarator, type);
11139                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11140                   {
11141                     DECL_MUTABLE_P (decl) = 1;
11142                     RIDBIT_RESET (RID_MUTABLE, specbits);
11143                   }
11144               }
11145
11146             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11147                             inlinep, friendp, raises != NULL_TREE);
11148           }
11149       }
11150     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11151       {
11152         tree original_name;
11153         int publicp = 0;
11154
11155         if (! declarator)
11156           return NULL_TREE;
11157
11158         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11159           original_name = dname;
11160         else
11161           original_name = declarator;
11162
11163         if (RIDBIT_SETP (RID_AUTO, specbits))
11164           error ("storage class `auto' invalid for function `%s'", name);
11165         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11166           error ("storage class `register' invalid for function `%s'", name);
11167
11168         /* Function declaration not at top level.
11169            Storage classes other than `extern' are not allowed
11170            and `extern' makes no difference.  */
11171         if (! toplevel_bindings_p ()
11172             && (RIDBIT_SETP (RID_STATIC, specbits)
11173                 || RIDBIT_SETP (RID_INLINE, specbits))
11174             && pedantic)
11175           {
11176             if (RIDBIT_SETP (RID_STATIC, specbits))
11177               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11178             else
11179               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11180           }
11181
11182         if (ctype == NULL_TREE)
11183           {
11184             if (virtualp)
11185               {
11186                 error ("virtual non-class function `%s'", name);
11187                 virtualp = 0;
11188               }
11189           }
11190         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11191           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11192                                           TYPE_ARG_TYPES (type));
11193
11194         /* Record presence of `static'.  */
11195         publicp = (ctype != NULL_TREE
11196                    || RIDBIT_SETP (RID_EXTERN, specbits)
11197                    || !RIDBIT_SETP (RID_STATIC, specbits));
11198
11199         decl = grokfndecl (ctype, type, original_name, declarator,
11200                            virtualp, flags, quals, raises,
11201                            1, friendp,
11202                            publicp, inlinep, funcdef_flag,
11203                            template_count, in_namespace);
11204         if (decl == NULL_TREE)
11205           return NULL_TREE;
11206
11207         if (staticp == 1)
11208           {
11209             int illegal_static = 0;
11210
11211             /* Don't allow a static member function in a class, and forbid
11212                declaring main to be static.  */
11213             if (TREE_CODE (type) == METHOD_TYPE)
11214               {
11215                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11216                 illegal_static = 1;
11217               }
11218             else if (current_function_decl)
11219               {
11220                 /* FIXME need arm citation */
11221                 error ("cannot declare static function inside another function");
11222                 illegal_static = 1;
11223               }
11224
11225             if (illegal_static)
11226               {
11227                 staticp = 0;
11228                 RIDBIT_RESET (RID_STATIC, specbits);
11229               }
11230           }
11231       }
11232     else
11233       {
11234         /* It's a variable.  */
11235
11236         /* An uninitialized decl with `extern' is a reference.  */
11237         decl = grokvardecl (type, declarator, &specbits,
11238                             initialized,
11239                             (type_quals & TYPE_QUAL_CONST) != 0,
11240                             in_namespace);
11241         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11242                         inlinep, friendp, raises != NULL_TREE);
11243
11244         if (ctype)
11245           {
11246             DECL_CONTEXT (decl) = ctype;
11247             if (staticp == 1)
11248               {
11249                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11250                 staticp = 0;
11251                 RIDBIT_RESET (RID_STATIC, specbits);
11252               }
11253             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11254               {
11255                 cp_error ("static member `%D' declared `register'", decl);
11256                 RIDBIT_RESET (RID_REGISTER, specbits);
11257               }
11258             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11259               {
11260                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11261                             decl);
11262                 RIDBIT_RESET (RID_EXTERN, specbits);
11263               }
11264           }
11265       }
11266
11267     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11268
11269     /* Record `register' declaration for warnings on &
11270        and in case doing stupid register allocation.  */
11271
11272     if (RIDBIT_SETP (RID_REGISTER, specbits))
11273       DECL_REGISTER (decl) = 1;
11274
11275     if (RIDBIT_SETP (RID_EXTERN, specbits))
11276       DECL_THIS_EXTERN (decl) = 1;
11277
11278     if (RIDBIT_SETP (RID_STATIC, specbits))
11279       DECL_THIS_STATIC (decl) = 1;
11280
11281     /* Record constancy and volatility.  There's no need to do this
11282        when processing a template; we'll do this for the instantiated
11283        declaration based on the type of DECL.  */
11284     if (!processing_template_decl)
11285       c_apply_type_quals_to_decl (type_quals, decl);
11286
11287     return decl;
11288   }
11289 }
11290 \f
11291 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11292    An empty exprlist is a parmlist.  An exprlist which
11293    contains only identifiers at the global level
11294    is a parmlist.  Otherwise, it is an exprlist.  */
11295
11296 int
11297 parmlist_is_exprlist (exprs)
11298      tree exprs;
11299 {
11300   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11301     return 0;
11302
11303   if (toplevel_bindings_p ())
11304     {
11305       /* At the global level, if these are all identifiers,
11306          then it is a parmlist.  */
11307       while (exprs)
11308         {
11309           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11310             return 1;
11311           exprs = TREE_CHAIN (exprs);
11312         }
11313       return 0;
11314     }
11315   return 1;
11316 }
11317
11318 /* Subroutine of start_function.  Ensure that each of the parameter
11319    types (as listed in PARMS) is complete, as is required for a
11320    function definition.  */
11321
11322 static void
11323 require_complete_types_for_parms (parms)
11324      tree parms;
11325 {
11326   for (; parms; parms = TREE_CHAIN (parms))
11327     {
11328       tree type = TREE_TYPE (parms);
11329
11330       /* Try to complete the TYPE.  */
11331       type = complete_type (type);
11332
11333       if (type == error_mark_node)
11334         continue;
11335
11336       if (TYPE_SIZE (type) == NULL_TREE)
11337         {
11338           if (DECL_NAME (parms))
11339             error ("parameter `%s' has incomplete type",
11340                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11341           else
11342             error ("parameter has incomplete type");
11343           TREE_TYPE (parms) = error_mark_node;
11344         }
11345       else
11346         layout_decl (parms, 0);
11347     }
11348 }
11349
11350 /* Returns non-zero if T is a local variable.  */
11351
11352 int
11353 local_variable_p (t)
11354      tree t;
11355 {
11356   if ((TREE_CODE (t) == VAR_DECL
11357        /* A VAR_DECL with a context that is a _TYPE is a static data
11358           member.  */
11359        && !TYPE_P (CP_DECL_CONTEXT (t))
11360        /* Any other non-local variable must be at namespace scope.  */
11361        && !DECL_NAMESPACE_SCOPE_P (t))
11362       || (TREE_CODE (t) == PARM_DECL))
11363     return 1;
11364
11365   return 0;
11366 }
11367
11368 /* Returns non-zero if T is an automatic local variable or a label.
11369    (These are the declarations that need to be remapped when the code
11370    containing them is duplicated.)  */
11371
11372 int
11373 nonstatic_local_decl_p (t)
11374      tree t;
11375 {
11376   return ((local_variable_p (t) && !TREE_STATIC (t))
11377           || TREE_CODE (t) == LABEL_DECL
11378           || TREE_CODE (t) == RESULT_DECL);
11379 }
11380
11381 /* Like local_variable_p, but suitable for use as a tree-walking
11382    function.  */
11383
11384 static tree
11385 local_variable_p_walkfn (tp, walk_subtrees, data)
11386      tree *tp;
11387      int *walk_subtrees ATTRIBUTE_UNUSED;
11388      void *data ATTRIBUTE_UNUSED;
11389 {
11390   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11391           ? *tp : NULL_TREE);
11392 }
11393
11394 /* Check that ARG, which is a default-argument expression for a
11395    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11396    something goes wrong.  DECL may also be a _TYPE node, rather than a
11397    DECL, if there is no DECL available.  */
11398
11399 tree
11400 check_default_argument (decl, arg)
11401      tree decl;
11402      tree arg;
11403 {
11404   tree var;
11405   tree decl_type;
11406
11407   if (TREE_CODE (arg) == DEFAULT_ARG)
11408     /* We get a DEFAULT_ARG when looking at an in-class declaration
11409        with a default argument.  Ignore the argument for now; we'll
11410        deal with it after the class is complete.  */
11411     return arg;
11412
11413   if (processing_template_decl || uses_template_parms (arg))
11414     /* We don't do anything checking until instantiation-time.  Note
11415        that there may be uninstantiated arguments even for an
11416        instantiated function, since default arguments are not
11417        instantiated until they are needed.  */
11418     return arg;
11419
11420   if (TYPE_P (decl))
11421     {
11422       decl_type = decl;
11423       decl = NULL_TREE;
11424     }
11425   else
11426     decl_type = TREE_TYPE (decl);
11427
11428   if (arg == error_mark_node
11429       || decl == error_mark_node
11430       || TREE_TYPE (arg) == error_mark_node
11431       || decl_type == error_mark_node)
11432     /* Something already went wrong.  There's no need to check
11433        further.  */
11434     return error_mark_node;
11435
11436   /* [dcl.fct.default]
11437
11438      A default argument expression is implicitly converted to the
11439      parameter type.  */
11440   if (!TREE_TYPE (arg)
11441       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11442     {
11443       if (decl)
11444         cp_error ("default argument for `%#D' has type `%T'",
11445                   decl, TREE_TYPE (arg));
11446       else
11447         cp_error ("default argument for parameter of type `%T' has type `%T'",
11448                   decl_type, TREE_TYPE (arg));
11449
11450       return error_mark_node;
11451     }
11452
11453   /* [dcl.fct.default]
11454
11455      Local variables shall not be used in default argument
11456      expressions.
11457
11458      The keyword `this' shall not be used in a default argument of a
11459      member function.  */
11460   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11461   if (var)
11462     {
11463       cp_error ("default argument `%E' uses local variable `%D'",
11464                 arg, var);
11465       return error_mark_node;
11466     }
11467
11468   /* All is well.  */
11469   return arg;
11470 }
11471
11472 /* Decode the list of parameter types for a function type.
11473    Given the list of things declared inside the parens,
11474    return a list of types.
11475
11476    The list we receive can have three kinds of elements:
11477    an IDENTIFIER_NODE for names given without types,
11478    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11479    or void_type_node, to mark the end of an argument list
11480    when additional arguments are not permitted (... was not used).
11481
11482    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11483    a mere declaration.  A nonempty identifier-list gets an error message
11484    when FUNCDEF_FLAG is zero.
11485    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11486    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11487
11488    If all elements of the input list contain types,
11489    we return a list of the types.
11490    If all elements contain no type (except perhaps a void_type_node
11491    at the end), we return a null list.
11492    If some have types and some do not, it is an error, and we
11493    return a null list.
11494
11495    Also set last_function_parms to either
11496    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11497    A list of names is converted to a chain of PARM_DECLs
11498    by store_parm_decls so that ultimately it is always a chain of decls.
11499
11500    Note that in C++, parameters can take default values.  These default
11501    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11502    an error to specify default values which are followed by parameters
11503    that have no default values, or an ELLIPSES.  For simplicities sake,
11504    only parameters which are specified with their types can take on
11505    default values.  */
11506
11507 static tree
11508 grokparms (first_parm, funcdef_flag)
11509      tree first_parm;
11510      int funcdef_flag;
11511 {
11512   tree result = NULL_TREE;
11513   tree decls = NULL_TREE;
11514
11515   if (first_parm != NULL_TREE
11516       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11517     {
11518       if (! funcdef_flag)
11519         pedwarn ("parameter names (without types) in function declaration");
11520       last_function_parms = first_parm;
11521       return NULL_TREE;
11522     }
11523   else if (first_parm != NULL_TREE
11524            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11525            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11526     my_friendly_abort (145);
11527   else
11528     {
11529       /* Types were specified.  This is a list of declarators
11530          each represented as a TREE_LIST node.  */
11531       register tree parm, chain;
11532       int any_init = 0, any_error = 0;
11533
11534       if (first_parm != NULL_TREE)
11535         {
11536           tree last_result = NULL_TREE;
11537           tree last_decl = NULL_TREE;
11538
11539           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11540             {
11541               tree type = NULL_TREE, list_node = parm;
11542               register tree decl = TREE_VALUE (parm);
11543               tree init = TREE_PURPOSE (parm);
11544
11545               chain = TREE_CHAIN (parm);
11546               /* @@ weak defense against parse errors.  */
11547               if (TREE_CODE (decl) != VOID_TYPE
11548                   && TREE_CODE (decl) != TREE_LIST)
11549                 {
11550                   /* Give various messages as the need arises.  */
11551                   if (TREE_CODE (decl) == STRING_CST)
11552                     cp_error ("invalid string constant `%E'", decl);
11553                   else if (TREE_CODE (decl) == INTEGER_CST)
11554                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11555                   continue;
11556                 }
11557
11558               if (TREE_CODE (decl) != VOID_TYPE)
11559                 {
11560                   decl = grokdeclarator (TREE_VALUE (decl),
11561                                          TREE_PURPOSE (decl),
11562                                          PARM, init != NULL_TREE,
11563                                          NULL_TREE);
11564                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11565                     continue;
11566
11567                   /* Top-level qualifiers on the parameters are
11568                      ignored for function types.  */
11569                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11570
11571                   if (TREE_CODE (type) == VOID_TYPE)
11572                     decl = void_type_node;
11573                   else if (TREE_CODE (type) == METHOD_TYPE)
11574                     {
11575                       if (DECL_NAME (decl))
11576                         /* Cannot use the decl here because
11577                            we don't have DECL_CONTEXT set up yet.  */
11578                         cp_error ("parameter `%D' invalidly declared method type",
11579                                   DECL_NAME (decl));
11580                       else
11581                         error ("parameter invalidly declared method type");
11582                       type = build_pointer_type (type);
11583                       TREE_TYPE (decl) = type;
11584                     }
11585                   else if (TREE_CODE (type) == OFFSET_TYPE)
11586                     {
11587                       if (DECL_NAME (decl))
11588                         cp_error ("parameter `%D' invalidly declared offset type",
11589                                   DECL_NAME (decl));
11590                       else
11591                         error ("parameter invalidly declared offset type");
11592                       type = build_pointer_type (type);
11593                       TREE_TYPE (decl) = type;
11594                     }
11595                   else if (abstract_virtuals_error (decl, type))
11596                     any_error = 1;  /* Seems like a good idea. */
11597                   else if (POINTER_TYPE_P (type))
11598                     {
11599                       tree t = type;
11600                       while (POINTER_TYPE_P (t)
11601                              || (TREE_CODE (t) == ARRAY_TYPE
11602                                  && TYPE_DOMAIN (t) != NULL_TREE))
11603                         t = TREE_TYPE (t);
11604                       if (TREE_CODE (t) == ARRAY_TYPE)
11605                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
11606                                   type,
11607                                   TYPE_PTR_P (type) ? "pointer" : "reference");
11608                     }
11609                 }
11610
11611               if (TREE_CODE (decl) == VOID_TYPE)
11612                 {
11613                   if (result == NULL_TREE)
11614                     {
11615                       result = void_list_node;
11616                       last_result = result;
11617                     }
11618                   else
11619                     {
11620                       TREE_CHAIN (last_result) = void_list_node;
11621                       last_result = void_list_node;
11622                     }
11623                   if (chain
11624                       && (chain != void_list_node || TREE_CHAIN (chain)))
11625                     error ("`void' in parameter list must be entire list");
11626                   break;
11627                 }
11628
11629               /* Since there is a prototype, args are passed in their own types.  */
11630               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11631               if (PROMOTE_PROTOTYPES
11632                   && (TREE_CODE (type) == INTEGER_TYPE
11633                       || TREE_CODE (type) == ENUMERAL_TYPE)
11634                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11635                 DECL_ARG_TYPE (decl) = integer_type_node;
11636               if (!any_error && init)
11637                 {
11638                   any_init++;
11639                   init = check_default_argument (decl, init);
11640                 }
11641               else
11642                 init = NULL_TREE;
11643
11644               if (decls == NULL_TREE)
11645                 {
11646                   decls = decl;
11647                   last_decl = decls;
11648                 }
11649               else
11650                 {
11651                   TREE_CHAIN (last_decl) = decl;
11652                   last_decl = decl;
11653                 }
11654               list_node = tree_cons (init, type, NULL_TREE);
11655               if (result == NULL_TREE)
11656                 {
11657                   result = list_node;
11658                   last_result = result;
11659                 }
11660               else
11661                 {
11662                   TREE_CHAIN (last_result) = list_node;
11663                   last_result = list_node;
11664                 }
11665             }
11666           if (last_result)
11667             TREE_CHAIN (last_result) = NULL_TREE;
11668           /* If there are no parameters, and the function does not end
11669              with `...', then last_decl will be NULL_TREE.  */
11670           if (last_decl != NULL_TREE)
11671             TREE_CHAIN (last_decl) = NULL_TREE;
11672         }
11673     }
11674
11675   last_function_parms = decls;
11676
11677   return result;
11678 }
11679
11680 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11681    FUNCTION_TYPE with the newly parsed version of its default argument, which
11682    was previously digested as text.  See snarf_defarg et al in lex.c.  */
11683
11684 void
11685 replace_defarg (arg, init)
11686      tree arg, init;
11687 {
11688   if (! processing_template_decl
11689       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11690     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11691                 TREE_TYPE (init), TREE_VALUE (arg));
11692   TREE_PURPOSE (arg) = init;
11693 }
11694 \f
11695 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11696    D's arguments allow it to be a copy constructor, or copy assignment
11697    operator.  */
11698
11699 int
11700 copy_args_p (d)
11701      tree d;
11702 {
11703   tree t;
11704
11705   if (!DECL_FUNCTION_MEMBER_P (d))
11706     return 0;
11707
11708   t = FUNCTION_ARG_CHAIN (d);
11709   if (DECL_CONSTRUCTOR_P (d)
11710       && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
11711     t = TREE_CHAIN (t);
11712   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11713       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11714           == DECL_CONTEXT (d))
11715       && (TREE_CHAIN (t) == NULL_TREE
11716           || TREE_CHAIN (t) == void_list_node
11717           || TREE_PURPOSE (TREE_CHAIN (t))))
11718     return 1;
11719   return 0;
11720 }
11721
11722 /* These memoizing functions keep track of special properties which
11723    a class may have.  `grok_ctor_properties' notices whether a class
11724    has a constructor of the form X(X&), and also complains
11725    if the class has a constructor of the form X(X).
11726    `grok_op_properties' takes notice of the various forms of
11727    operator= which are defined, as well as what sorts of type conversion
11728    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11729
11730 int
11731 grok_ctor_properties (ctype, decl)
11732      tree ctype, decl;
11733 {
11734   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11735   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11736
11737   /* When a type has virtual baseclasses, a magical first int argument is
11738      added to any ctor so we can tell if the class has been initialized
11739      yet.  This could screw things up in this function, so we deliberately
11740      ignore the leading int if we're in that situation.  */
11741   if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
11742     {
11743       my_friendly_assert (parmtypes
11744                           && TREE_VALUE (parmtypes) == integer_type_node,
11745                           980529);
11746       parmtypes = TREE_CHAIN (parmtypes);
11747       parmtype = TREE_VALUE (parmtypes);
11748     }
11749
11750   /* [class.copy]
11751
11752      A non-template constructor for class X is a copy constructor if
11753      its first parameter is of type X&, const X&, volatile X& or const
11754      volatile X&, and either there are no other parameters or else all
11755      other parameters have default arguments.  */
11756   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11757       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11758       && (TREE_CHAIN (parmtypes) == NULL_TREE
11759           || TREE_CHAIN (parmtypes) == void_list_node
11760           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11761       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11762            && is_member_template (DECL_TI_TEMPLATE (decl))))
11763     {
11764       TYPE_HAS_INIT_REF (ctype) = 1;
11765       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11766         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11767     }
11768   /* [class.copy]
11769
11770      A declaration of a constructor for a class X is ill-formed if its
11771      first parameter is of type (optionally cv-qualified) X and either
11772      there are no other parameters or else all other parameters have
11773      default arguments.
11774
11775      We *don't* complain about member template instantiations that
11776      have this form, though; they can occur as we try to decide what
11777      constructor to use during overload resolution.  Since overload
11778      resolution will never prefer such a constructor to the
11779      non-template copy constructor (which is either explicitly or
11780      implicitly defined), there's no need to worry about their
11781      existence.  Theoretically, they should never even be
11782      instantiated, but that's hard to forestall.  */
11783   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11784            && (TREE_CHAIN (parmtypes) == NULL_TREE
11785                || TREE_CHAIN (parmtypes) == void_list_node
11786                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11787            && !(DECL_TEMPLATE_INSTANTIATION (decl)
11788                 && is_member_template (DECL_TI_TEMPLATE (decl))))
11789     {
11790       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11791                 ctype, ctype);
11792       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
11793       return 0;
11794     }
11795   else if (TREE_CODE (parmtype) == VOID_TYPE
11796            || TREE_PURPOSE (parmtypes) != NULL_TREE)
11797     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
11798
11799   return 1;
11800 }
11801
11802 /* An operator with this name can be either unary or binary.  */
11803
11804 static int
11805 ambi_op_p (name)
11806      tree name;
11807 {
11808   return (name == ansi_opname [(int) INDIRECT_REF]
11809           || name == ansi_opname [(int) ADDR_EXPR]
11810           || name == ansi_opname [(int) NEGATE_EXPR]
11811           || name == ansi_opname[(int) POSTINCREMENT_EXPR]
11812           || name == ansi_opname[(int) POSTDECREMENT_EXPR]
11813           || name == ansi_opname [(int) CONVERT_EXPR]);
11814 }
11815
11816 /* An operator with this name can only be unary.  */
11817
11818 static int
11819 unary_op_p (name)
11820      tree name;
11821 {
11822   return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
11823           || name == ansi_opname [(int) BIT_NOT_EXPR]
11824           || name == ansi_opname [(int) COMPONENT_REF]
11825           || IDENTIFIER_TYPENAME_P (name));
11826 }
11827
11828 /* Do a little sanity-checking on how they declared their operator.  */
11829
11830 void
11831 grok_op_properties (decl, virtualp, friendp)
11832      tree decl;
11833      int virtualp, friendp;
11834 {
11835   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11836   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11837   tree name = DECL_NAME (decl);
11838
11839   if (current_class_type == NULL_TREE)
11840     friendp = 1;
11841
11842   if (! friendp)
11843     {
11844       /* [class.copy]
11845
11846          A user-declared copy assignment operator X::operator= is a
11847          non-static non-template member function of class X with
11848          exactly one parameter of type X, X&, const X&, volatile X& or
11849          const volatile X&.  */
11850       if (name == ansi_opname[(int) MODIFY_EXPR]
11851           && !(DECL_TEMPLATE_INSTANTIATION (decl)
11852                && is_member_template (DECL_TI_TEMPLATE (decl))))
11853         ;
11854       else if (name == ansi_opname[(int) CALL_EXPR])
11855         TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
11856       else if (name == ansi_opname[(int) ARRAY_REF])
11857         TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
11858       else if (name == ansi_opname[(int) COMPONENT_REF]
11859                || name == ansi_opname[(int) MEMBER_REF])
11860         TYPE_OVERLOADS_ARROW (current_class_type) = 1;
11861       else if (name == ansi_opname[(int) NEW_EXPR])
11862         TYPE_GETS_NEW (current_class_type) |= 1;
11863       else if (name == ansi_opname[(int) DELETE_EXPR])
11864         TYPE_GETS_DELETE (current_class_type) |= 1;
11865       else if (name == ansi_opname[(int) VEC_NEW_EXPR])
11866         TYPE_GETS_NEW (current_class_type) |= 2;
11867       else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
11868         TYPE_GETS_DELETE (current_class_type) |= 2;
11869     }
11870
11871   if (name == ansi_opname[(int) NEW_EXPR]
11872       || name == ansi_opname[(int) VEC_NEW_EXPR])
11873     {
11874       /* When the compiler encounters the definition of A::operator new, it
11875          doesn't look at the class declaration to find out if it's static.  */
11876       if (methodp)
11877         revert_static_member_fn (&decl, NULL, NULL);
11878
11879       /* Take care of function decl if we had syntax errors.  */
11880       if (argtypes == NULL_TREE)
11881         TREE_TYPE (decl)
11882           = build_function_type (ptr_type_node,
11883                                  hash_tree_chain (integer_type_node,
11884                                                   void_list_node));
11885       else
11886         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
11887     }
11888   else if (name == ansi_opname[(int) DELETE_EXPR]
11889            || name == ansi_opname[(int) VEC_DELETE_EXPR])
11890     {
11891       if (methodp)
11892         revert_static_member_fn (&decl, NULL, NULL);
11893
11894       if (argtypes == NULL_TREE)
11895         TREE_TYPE (decl)
11896           = build_function_type (void_type_node,
11897                                  hash_tree_chain (ptr_type_node,
11898                                                   void_list_node));
11899       else
11900         {
11901           TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
11902
11903           if (! friendp && name == ansi_opname[(int) VEC_DELETE_EXPR]
11904               && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
11905                   != void_list_node))
11906             TYPE_VEC_DELETE_TAKES_SIZE (current_class_type) = 1;
11907         }
11908     }
11909   else
11910     {
11911       /* An operator function must either be a non-static member function
11912          or have at least one parameter of a class, a reference to a class,
11913          an enumeration, or a reference to an enumeration.  13.4.0.6 */
11914       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
11915         {
11916           if (IDENTIFIER_TYPENAME_P (name)
11917               || name == ansi_opname[(int) CALL_EXPR]
11918               || name == ansi_opname[(int) MODIFY_EXPR]
11919               || name == ansi_opname[(int) COMPONENT_REF]
11920               || name == ansi_opname[(int) ARRAY_REF])
11921             cp_error ("`%D' must be a nonstatic member function", decl);
11922           else
11923             {
11924               tree p = argtypes;
11925
11926               if (DECL_STATIC_FUNCTION_P (decl))
11927                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
11928
11929               if (p)
11930                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
11931                   {
11932                     tree arg = TREE_VALUE (p);
11933                     if (TREE_CODE (arg) == REFERENCE_TYPE)
11934                       arg = TREE_TYPE (arg);
11935
11936                     /* This lets bad template code slip through.  */
11937                     if (IS_AGGR_TYPE (arg)
11938                         || TREE_CODE (arg) == ENUMERAL_TYPE
11939                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
11940                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
11941                       goto foundaggr;
11942                   }
11943               cp_error
11944                 ("`%D' must have an argument of class or enumerated type",
11945                  decl);
11946             foundaggr:
11947               ;
11948             }
11949         }
11950
11951       if (name == ansi_opname[(int) CALL_EXPR])
11952         return;                 /* No restrictions on args. */
11953
11954       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
11955         {
11956           tree t = TREE_TYPE (name);
11957           if (TREE_CODE (t) == VOID_TYPE)
11958             pedwarn ("void is not a valid type conversion operator");
11959           else if (! friendp)
11960             {
11961               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
11962               const char *what = 0;
11963               if (ref)
11964                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
11965
11966               if (t == current_class_type)
11967                 what = "the same type";
11968               /* Don't force t to be complete here.  */
11969               else if (IS_AGGR_TYPE (t)
11970                        && TYPE_SIZE (t)
11971                        && DERIVED_FROM_P (t, current_class_type))
11972                 what = "a base class";
11973
11974               if (what)
11975                 warning ("conversion to %s%s will never use a type conversion operator",
11976                          ref ? "a reference to " : "", what);
11977             }
11978         }
11979
11980       if (name == ansi_opname[(int) MODIFY_EXPR])
11981         {
11982           tree parmtype;
11983
11984           if (list_length (argtypes) != 3 && methodp)
11985             {
11986               cp_error ("`%D' must take exactly one argument", decl);
11987               return;
11988             }
11989           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
11990
11991           if (copy_assignment_arg_p (parmtype, virtualp)
11992               && ! friendp)
11993             {
11994               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
11995               if (TREE_CODE (parmtype) != REFERENCE_TYPE
11996                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11997                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
11998             }
11999         }
12000       else if (name == ansi_opname[(int) COND_EXPR])
12001         {
12002           /* 13.4.0.3 */
12003           cp_error ("ISO C++ prohibits overloading operator ?:");
12004         }
12005       else if (ambi_op_p (name))
12006         {
12007           if (list_length (argtypes) == 2)
12008             /* prefix */;
12009           else if (list_length (argtypes) == 3)
12010             {
12011               if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
12012                    || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12013                   && ! processing_template_decl
12014                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12015                 {
12016                   if (methodp)
12017                     cp_error ("postfix `%D' must take `int' as its argument",
12018                               decl);
12019                   else
12020                     cp_error
12021                       ("postfix `%D' must take `int' as its second argument",
12022                        decl);
12023                 }
12024             }
12025           else
12026             {
12027               if (methodp)
12028                 cp_error ("`%D' must take either zero or one argument", decl);
12029               else
12030                 cp_error ("`%D' must take either one or two arguments", decl);
12031             }
12032
12033           /* More Effective C++ rule 6.  */
12034           if (warn_ecpp
12035               && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12036                   || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
12037             {
12038               tree arg = TREE_VALUE (argtypes);
12039               tree ret = TREE_TYPE (TREE_TYPE (decl));
12040               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12041                 arg = TREE_TYPE (arg);
12042               arg = TYPE_MAIN_VARIANT (arg);
12043               if (list_length (argtypes) == 2)
12044                 {
12045                   if (TREE_CODE (ret) != REFERENCE_TYPE
12046                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12047                                        arg))
12048                     cp_warning ("prefix `%D' should return `%T'", decl,
12049                                 build_reference_type (arg));
12050                 }
12051               else
12052                 {
12053                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12054                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12055                 }
12056             }
12057         }
12058       else if (unary_op_p (name))
12059         {
12060           if (list_length (argtypes) != 2)
12061             {
12062               if (methodp)
12063                 cp_error ("`%D' must take `void'", decl);
12064               else
12065                 cp_error ("`%D' must take exactly one argument", decl);
12066             }
12067         }
12068       else /* if (binary_op_p (name)) */
12069         {
12070           if (list_length (argtypes) != 3)
12071             {
12072               if (methodp)
12073                 cp_error ("`%D' must take exactly one argument", decl);
12074               else
12075                 cp_error ("`%D' must take exactly two arguments", decl);
12076             }
12077
12078           /* More Effective C++ rule 7.  */
12079           if (warn_ecpp
12080               && (name == ansi_opname [TRUTH_ANDIF_EXPR]
12081                   || name == ansi_opname [TRUTH_ORIF_EXPR]
12082                   || name == ansi_opname [COMPOUND_EXPR]))
12083             cp_warning ("user-defined `%D' always evaluates both arguments",
12084                         decl);
12085         }
12086
12087       /* Effective C++ rule 23.  */
12088       if (warn_ecpp
12089           && list_length (argtypes) == 3
12090           && (name == ansi_opname [PLUS_EXPR]
12091               || name == ansi_opname [MINUS_EXPR]
12092               || name == ansi_opname [TRUNC_DIV_EXPR]
12093               || name == ansi_opname [MULT_EXPR])
12094           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12095         cp_warning ("`%D' should return by value", decl);
12096
12097       /* 13.4.0.8 */
12098       if (argtypes)
12099         for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
12100           if (TREE_PURPOSE (argtypes))
12101             {
12102               TREE_PURPOSE (argtypes) = NULL_TREE;
12103               if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12104                   || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12105                 {
12106                   if (pedantic)
12107                     cp_pedwarn ("`%D' cannot have default arguments", decl);
12108                 }
12109               else
12110                 cp_error ("`%D' cannot have default arguments", decl);
12111             }
12112     }
12113 }
12114 \f
12115 static const char *
12116 tag_name (code)
12117      enum tag_types code;
12118 {
12119   switch (code)
12120     {
12121     case record_type:
12122       return "struct";
12123     case class_type:
12124       return "class";
12125     case union_type:
12126       return "union ";
12127     case enum_type:
12128       return "enum";
12129     default:
12130       my_friendly_abort (981122);
12131     }
12132 }
12133
12134 /* Get the struct, enum or union (CODE says which) with tag NAME.
12135    Define the tag as a forward-reference if it is not defined.
12136
12137    C++: If a class derivation is given, process it here, and report
12138    an error if multiple derivation declarations are not identical.
12139
12140    If this is a definition, come in through xref_tag and only look in
12141    the current frame for the name (since C++ allows new names in any
12142    scope.)  */
12143
12144 tree
12145 xref_tag (code_type_node, name, globalize)
12146      tree code_type_node;
12147      tree name;
12148      int globalize;
12149 {
12150   enum tag_types tag_code;
12151   enum tree_code code;
12152   register tree ref, t;
12153   struct binding_level *b = current_binding_level;
12154   int got_type = 0;
12155   tree attributes = NULL_TREE;
12156   tree context = NULL_TREE;
12157
12158   /* If we are called from the parser, code_type_node will sometimes be a
12159      TREE_LIST.  This indicates that the user wrote
12160      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12161      use them later.  */
12162   if (TREE_CODE (code_type_node) == TREE_LIST)
12163     {
12164       attributes = TREE_PURPOSE (code_type_node);
12165       code_type_node = TREE_VALUE (code_type_node);
12166     }
12167
12168   tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12169   switch (tag_code)
12170     {
12171     case record_type:
12172     case class_type:
12173       code = RECORD_TYPE;
12174       break;
12175     case union_type:
12176       code = UNION_TYPE;
12177       break;
12178     case enum_type:
12179       code = ENUMERAL_TYPE;
12180       break;
12181     default:
12182       my_friendly_abort (18);
12183     }
12184
12185   /* If a cross reference is requested, look up the type
12186      already defined for this tag and return it.  */
12187   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
12188     {
12189       t = name;
12190       name = TYPE_IDENTIFIER (t);
12191       got_type = 1;
12192     }
12193   else
12194     t = IDENTIFIER_TYPE_VALUE (name);
12195
12196   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12197       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12198     t = NULL_TREE;
12199
12200   if (! globalize)
12201     {
12202       /* If we know we are defining this tag, only look it up in
12203          this scope and don't try to find it as a type.  */
12204       ref = lookup_tag (code, name, b, 1);
12205     }
12206   else
12207     {
12208       if (t)
12209         {
12210           /* [dcl.type.elab] If the identifier resolves to a
12211              typedef-name or a template type-parameter, the
12212              elaborated-type-specifier is ill-formed.  */
12213           if (t != TYPE_MAIN_VARIANT (t)
12214               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12215             cp_pedwarn ("using typedef-name `%D' after `%s'",
12216                         TYPE_NAME (t), tag_name (tag_code));
12217           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12218             cp_error ("using template type parameter `%T' after `%s'",
12219                       t, tag_name (tag_code));
12220
12221           ref = t;
12222         }
12223       else
12224         ref = lookup_tag (code, name, b, 0);
12225
12226       if (! ref)
12227         {
12228           /* Try finding it as a type declaration.  If that wins,
12229              use it.  */
12230           ref = lookup_name (name, 1);
12231
12232           if (ref != NULL_TREE
12233               && processing_template_decl
12234               && DECL_CLASS_TEMPLATE_P (ref)
12235               && template_class_depth (current_class_type) == 0)
12236             /* Since GLOBALIZE is true, we're declaring a global
12237                template, so we want this type.  */
12238             ref = DECL_RESULT (ref);
12239
12240           if (ref && TREE_CODE (ref) == TYPE_DECL
12241               && TREE_CODE (TREE_TYPE (ref)) == code)
12242             ref = TREE_TYPE (ref);
12243           else
12244             ref = NULL_TREE;
12245         }
12246
12247       if (ref && current_class_type
12248           && template_class_depth (current_class_type)
12249           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12250         {
12251           /* Since GLOBALIZE is non-zero, we are not looking at a
12252              definition of this tag.  Since, in addition, we are currently
12253              processing a (member) template declaration of a template
12254              class, we must be very careful; consider:
12255
12256                template <class X>
12257                struct S1
12258
12259                template <class U>
12260                struct S2
12261                { template <class V>
12262                friend struct S1; };
12263
12264              Here, the S2::S1 declaration should not be confused with the
12265              outer declaration.  In particular, the inner version should
12266              have a template parameter of level 2, not level 1.  This
12267              would be particularly important if the member declaration
12268              were instead:
12269
12270                template <class V = U> friend struct S1;
12271
12272              say, when we should tsubst into `U' when instantiating
12273              S2.  On the other hand, when presented with:
12274
12275                  template <class T>
12276                  struct S1 {
12277                    template <class U>
12278                    struct S2 {};
12279                    template <class U>
12280                    friend struct S2;
12281                  };
12282
12283               we must find the inner binding eventually.  We
12284               accomplish this by making sure that the new type we
12285               create to represent this declaration has the right
12286               TYPE_CONTEXT.  */
12287           context = TYPE_CONTEXT (ref);
12288           ref = NULL_TREE;
12289         }
12290     }
12291
12292   if (! ref)
12293     {
12294       /* If no such tag is yet defined, create a forward-reference node
12295          and record it as the "definition".
12296          When a real declaration of this type is found,
12297          the forward-reference will be altered into a real type.  */
12298       if (code == ENUMERAL_TYPE)
12299         {
12300           cp_error ("use of enum `%#D' without previous declaration", name);
12301
12302           ref = make_node (ENUMERAL_TYPE);
12303
12304           /* Give the type a default layout like unsigned int
12305              to avoid crashing if it does not get defined.  */
12306           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12307           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12308           TREE_UNSIGNED (ref) = 1;
12309           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12310           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12311           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12312
12313           /* Enable us to recognize when a type is created in class context.
12314              To do nested classes correctly, this should probably be cleared
12315              out when we leave this classes scope.  Currently this in only
12316              done in `start_enum'.  */
12317
12318           pushtag (name, ref, globalize);
12319         }
12320       else
12321         {
12322           struct binding_level *old_b = class_binding_level;
12323
12324           ref = make_aggr_type (code);
12325           TYPE_CONTEXT (ref) = context;
12326
12327 #ifdef NONNESTED_CLASSES
12328           /* Class types don't nest the way enums do.  */
12329           class_binding_level = (struct binding_level *)0;
12330 #endif
12331           pushtag (name, ref, globalize);
12332           class_binding_level = old_b;
12333         }
12334     }
12335   else
12336     {
12337       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12338         redeclare_class_template (ref, current_template_parms);
12339     }
12340
12341   /* Until the type is defined, tentatively accept whatever
12342      structure tag the user hands us.  */
12343   if (TYPE_SIZE (ref) == NULL_TREE
12344       && ref != current_class_type
12345       /* Have to check this, in case we have contradictory tag info.  */
12346       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12347     {
12348       if (tag_code == class_type)
12349         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12350       else if (tag_code == record_type)
12351         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12352     }
12353
12354   TREE_TYPE (ref) = attributes;
12355
12356   return ref;
12357 }
12358
12359 tree
12360 xref_tag_from_type (old, id, globalize)
12361      tree old, id;
12362      int globalize;
12363 {
12364   tree code_type_node;
12365
12366   if (TREE_CODE (old) == RECORD_TYPE)
12367     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12368                       ? class_type_node : record_type_node);
12369   else
12370     code_type_node = union_type_node;
12371
12372   if (id == NULL_TREE)
12373     id = TYPE_IDENTIFIER (old);
12374
12375   return xref_tag (code_type_node, id, globalize);
12376 }
12377
12378 /* REF is a type (named NAME), for which we have just seen some
12379    baseclasses.  BINFO is a list of those baseclasses; the
12380    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12381    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12382    struct, or union.  */
12383
12384 void
12385 xref_basetypes (code_type_node, name, ref, binfo)
12386      tree code_type_node;
12387      tree name, ref;
12388      tree binfo;
12389 {
12390   /* In the declaration `A : X, Y, ... Z' we mark all the types
12391      (A, X, Y, ..., Z) so we can check for duplicates.  */
12392   tree binfos;
12393   tree base;
12394
12395   int i, len;
12396   enum tag_types tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12397
12398   if (tag_code == union_type)
12399     {
12400       cp_error ("derived union `%T' invalid", ref);
12401       return;
12402     }
12403
12404   len = list_length (binfo);
12405
12406   /* First, make sure that any templates in base-classes are
12407      instantiated.  This ensures that if we call ourselves recursively
12408      we do not get confused about which classes are marked and which
12409      are not.  */
12410   for (base = binfo; base; base = TREE_CHAIN (base))
12411     complete_type (TREE_VALUE (base));
12412
12413   SET_CLASSTYPE_MARKED (ref);
12414   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12415
12416   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12417     {
12418       /* The base of a derived struct is public by default.  */
12419       int via_public
12420         = (TREE_PURPOSE (binfo) == access_public_node
12421            || TREE_PURPOSE (binfo) == access_public_virtual_node
12422            || (tag_code != class_type
12423                && (TREE_PURPOSE (binfo) == access_default_node
12424                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12425       int via_protected
12426         = (TREE_PURPOSE (binfo) == access_protected_node
12427            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12428       int via_virtual
12429         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12430            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12431            || TREE_PURPOSE (binfo) == access_public_virtual_node
12432            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12433       tree basetype = TREE_VALUE (binfo);
12434       tree base_binfo;
12435
12436       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12437         basetype = TREE_TYPE (basetype);
12438       if (!basetype
12439           || (TREE_CODE (basetype) != RECORD_TYPE
12440               && TREE_CODE (basetype) != TYPENAME_TYPE
12441               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12442               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12443         {
12444           cp_error ("base type `%T' fails to be a struct or class type",
12445                     TREE_VALUE (binfo));
12446           continue;
12447         }
12448
12449       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12450
12451       /* This code replaces similar code in layout_basetypes.
12452          We put the complete_type first for implicit `typename'.  */
12453       if (TYPE_SIZE (basetype) == NULL_TREE
12454           && ! (current_template_parms && uses_template_parms (basetype)))
12455         {
12456           cp_error ("base class `%T' has incomplete type", basetype);
12457           continue;
12458         }
12459       else
12460         {
12461           if (CLASSTYPE_MARKED (basetype))
12462             {
12463               if (basetype == ref)
12464                 cp_error ("recursive type `%T' undefined", basetype);
12465               else
12466                 cp_error ("duplicate base type `%T' invalid", basetype);
12467               continue;
12468             }
12469
12470           if (TYPE_FOR_JAVA (basetype)
12471               && (current_lang_stack
12472                   == &VARRAY_TREE (current_lang_base, 0)))
12473             TYPE_FOR_JAVA (ref) = 1;
12474
12475           /* Note that the BINFO records which describe individual
12476              inheritances are *not* shared in the lattice!  They
12477              cannot be shared because a given baseclass may be
12478              inherited with different `accessibility' by different
12479              derived classes.  (Each BINFO record describing an
12480              individual inheritance contains flags which say what
12481              the `accessibility' of that particular inheritance is.)  */
12482
12483           base_binfo
12484             = make_binfo (integer_zero_node, basetype,
12485                           CLASS_TYPE_P (basetype)
12486                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12487                           CLASS_TYPE_P (basetype)
12488                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12489
12490           TREE_VEC_ELT (binfos, i) = base_binfo;
12491           TREE_VIA_PUBLIC (base_binfo) = via_public;
12492           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12493           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12494           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12495
12496           /* We need to unshare the binfos now so that lookups during class
12497              definition work.  */
12498           unshare_base_binfos (base_binfo);
12499
12500           SET_CLASSTYPE_MARKED (basetype);
12501
12502           /* We are free to modify these bits because they are meaningless
12503              at top level, and BASETYPE is a top-level type.  */
12504           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12505             {
12506               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12507               /* Converting to a virtual base class requires looking
12508                  up the offset of the virtual base.  */
12509               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12510             }
12511
12512           if (CLASS_TYPE_P (basetype))
12513             {
12514               TYPE_GETS_NEW (ref) |= TYPE_GETS_NEW (basetype);
12515               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12516               /* If the base-class uses multiple inheritance, so do we.  */
12517               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12518                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12519               /* Likewise, if converting to a base of the base may require
12520                  code, then we may need to generate code to convert to a
12521                  base as well.  */
12522               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12523                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12524             }
12525
12526           i += 1;
12527         }
12528     }
12529   if (i)
12530     TREE_VEC_LENGTH (binfos) = i;
12531   else
12532     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12533
12534   if (i > 1)
12535     {
12536       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12537       /* If there is more than one non-empty they cannot be at the same
12538          address.  */
12539       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12540     }
12541
12542   /* Unmark all the types.  */
12543   while (--i >= 0)
12544     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12545   CLEAR_CLASSTYPE_MARKED (ref);
12546
12547   /* Now that we know all the base-classes, set up the list of virtual
12548      bases.  */
12549   get_vbase_types (ref);
12550 }
12551
12552 \f
12553 /* Begin compiling the definition of an enumeration type.
12554    NAME is its name (or null if anonymous).
12555    Returns the type object, as yet incomplete.
12556    Also records info about it so that build_enumerator
12557    may be used to declare the individual values as they are read.  */
12558
12559 tree
12560 start_enum (name)
12561      tree name;
12562 {
12563   register tree enumtype = NULL_TREE;
12564   struct binding_level *b = current_binding_level;
12565
12566   /* If this is the real definition for a previous forward reference,
12567      fill in the contents in the same object that used to be the
12568      forward reference.  */
12569
12570   if (name != NULL_TREE)
12571     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12572
12573   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12574     {
12575       cp_error ("multiple definition of `%#T'", enumtype);
12576       cp_error_at ("previous definition here", enumtype);
12577       /* Clear out TYPE_VALUES, and start again.  */
12578       TYPE_VALUES (enumtype) = NULL_TREE;
12579     }
12580   else
12581     {
12582       enumtype = make_node (ENUMERAL_TYPE);
12583       pushtag (name, enumtype, 0);
12584     }
12585
12586   if (current_class_type)
12587     TREE_ADDRESSABLE (b->tags) = 1;
12588
12589   GNU_xref_decl (current_function_decl, enumtype);
12590   return enumtype;
12591 }
12592
12593 /* After processing and defining all the values of an enumeration type,
12594    install their decls in the enumeration type and finish it off.
12595    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12596    Returns ENUMTYPE.  */
12597
12598 tree
12599 finish_enum (enumtype)
12600      tree enumtype;
12601 {
12602   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12603   /* Calculate the maximum value of any enumerator in this type.  */
12604
12605   tree values = TYPE_VALUES (enumtype);
12606   if (values)
12607     {
12608       tree pair;
12609
12610       for (pair = values; pair; pair = TREE_CHAIN (pair))
12611         {
12612           tree decl;
12613           tree value;
12614
12615           /* The TREE_VALUE is a CONST_DECL for this enumeration
12616              constant.  */
12617           decl = TREE_VALUE (pair);
12618
12619           /* [dcl.enum]
12620
12621              Following the closing brace of an enum-specifier, each
12622              enumerator has the type of its enumeration.  Prior to the
12623              closing brace, the type of each enumerator is the type of
12624              its initializing value.  */
12625           TREE_TYPE (decl) = enumtype;
12626
12627           /* The DECL_INITIAL will be NULL if we are processing a
12628              template declaration and this enumeration constant had no
12629              explicit initializer.  */
12630           value = DECL_INITIAL (decl);
12631           if (value && !processing_template_decl)
12632             {
12633               /* Set the TREE_TYPE for the VALUE as well.  That's so
12634                  that when we call decl_constant_value we get an
12635                  entity of the right type (but with the constant
12636                  value).  Since we shouldn't ever call
12637                  decl_constant_value on a template type, there's no
12638                  reason to do that when processing_template_decl.
12639                  And, if the expression is something like a
12640                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12641                  wreak havoc on the intended type of the expression.
12642
12643                  Of course, there's also no point in trying to compute
12644                  minimum or maximum values if we're in a template.  */
12645               TREE_TYPE (value) = enumtype;
12646
12647               if (!minnode)
12648                 minnode = maxnode = value;
12649               else if (tree_int_cst_lt (maxnode, value))
12650                 maxnode = value;
12651               else if (tree_int_cst_lt (value, minnode))
12652                 minnode = value;
12653             }
12654
12655           if (processing_template_decl)
12656             /* If this is just a template, leave the CONST_DECL
12657                alone.  That way tsubst_copy will find CONST_DECLs for
12658                CONST_DECLs, and not INTEGER_CSTs.  */
12659             ;
12660           else
12661             /* In the list we're building up, we want the enumeration
12662                values, not the CONST_DECLs.  */
12663             TREE_VALUE (pair) = value;
12664         }
12665     }
12666   else
12667     maxnode = minnode = integer_zero_node;
12668
12669   TYPE_VALUES (enumtype) = nreverse (values);
12670
12671   if (processing_template_decl)
12672     {
12673       tree scope = current_scope ();
12674       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12675         add_tree (build_min (TAG_DEFN, enumtype));
12676     }
12677   else
12678     {
12679       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12680       int lowprec = min_precision (minnode, unsignedp);
12681       int highprec = min_precision (maxnode, unsignedp);
12682       int precision = MAX (lowprec, highprec);
12683       tree tem;
12684
12685       TYPE_SIZE (enumtype) = NULL_TREE;
12686
12687       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12688
12689       TYPE_PRECISION (enumtype) = precision;
12690       if (unsignedp)
12691         fixup_unsigned_type (enumtype);
12692       else
12693         fixup_signed_type (enumtype);
12694
12695       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12696         /* Use the width of the narrowest normal C type which is wide
12697            enough.  */
12698         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12699                                                     (precision, 1));
12700       else
12701         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12702
12703       TYPE_SIZE (enumtype) = 0;
12704       layout_type (enumtype);
12705
12706       /* Fix up all variant types of this enum type.  */
12707       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12708            tem = TYPE_NEXT_VARIANT (tem))
12709         {
12710           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12711           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12712           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12713           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12714           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12715           TYPE_MODE (tem) = TYPE_MODE (enumtype);
12716           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12717           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12718           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12719         }
12720
12721       /* Finish debugging output for this type.  */
12722       rest_of_type_compilation (enumtype, namespace_bindings_p ());
12723     }
12724
12725   return enumtype;
12726 }
12727
12728 /* Build and install a CONST_DECL for an enumeration constant of the
12729    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12730    Assignment of sequential values by default is handled here.  */
12731
12732 void
12733 build_enumerator (name, value, enumtype)
12734      tree name;
12735      tree value;
12736      tree enumtype;
12737 {
12738   tree decl;
12739   tree context;
12740   tree type;
12741   tree values;
12742
12743   /* Remove no-op casts from the value.  */
12744   if (value)
12745     STRIP_TYPE_NOPS (value);
12746
12747   if (! processing_template_decl)
12748     {
12749       /* Validate and default VALUE.  */
12750       if (value != NULL_TREE)
12751         {
12752           if (TREE_READONLY_DECL_P (value))
12753             value = decl_constant_value (value);
12754
12755           if (TREE_CODE (value) == INTEGER_CST)
12756             {
12757               value = default_conversion (value);
12758               constant_expression_warning (value);
12759             }
12760           else
12761             {
12762               cp_error ("enumerator value for `%D' not integer constant", name);
12763               value = NULL_TREE;
12764             }
12765         }
12766
12767       /* Default based on previous value.  */
12768       if (value == NULL_TREE && ! processing_template_decl)
12769         {
12770           tree prev_value;
12771
12772           if (TYPE_VALUES (enumtype))
12773             {
12774               /* The next value is the previous value ... */
12775               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
12776               /* ... plus one.  */
12777               value = build_binary_op (PLUS_EXPR,
12778                                        prev_value,
12779                                        integer_one_node);
12780
12781               if (tree_int_cst_lt (value, prev_value))
12782                 cp_error ("overflow in enumeration values at `%D'", name);
12783             }
12784           else
12785             value = integer_zero_node;
12786         }
12787
12788       /* Remove no-op casts from the value.  */
12789       if (value)
12790         STRIP_TYPE_NOPS (value);
12791 #if 0
12792       /* To fix MAX_VAL enum consts. (bkoz)  */
12793       TREE_TYPE (value) = integer_type_node;
12794 #endif
12795     }
12796
12797   /* We always have to copy here; not all INTEGER_CSTs are unshared.
12798      Even in other cases, we will later (in finish_enum) be setting
12799      the type of VALUE.  But, we don't need to make a copy if this
12800      VALUE is one of the enumeration constants for this same
12801      enumeration type.  */
12802   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
12803     if (TREE_VALUE (values) == value)
12804       break;
12805   /* If we didn't break out of the loop, then we do need a copy.  */
12806   if (!values && value)
12807     value = copy_node (value);
12808
12809   /* C++ associates enums with global, function, or class declarations.  */
12810   context = current_scope ();
12811
12812   /* Build the actual enumeration constant.  Note that the enumeration
12813     constants have the type of their initializers until the
12814     enumeration is complete:
12815
12816       [ dcl.enum ]
12817
12818       Following the closing brace of an enum-specifier, each enumer-
12819       ator has the type of its enumeration.  Prior to the closing
12820       brace, the type of each enumerator is the type of its
12821       initializing value.
12822
12823     In finish_enum we will reset the type.  Of course, if we're
12824     processing a template, there may be no value.   */
12825   type = value ? TREE_TYPE (value) : NULL_TREE;
12826
12827   if (context && context == current_class_type)
12828     /* This enum declaration is local to the class.  We need the full
12829       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
12830     decl = build_lang_decl (CONST_DECL, name, type);
12831   else
12832     /* It's a global enum, or it's local to a function.  (Note local to
12833       a function could mean local to a class method.  */
12834     decl = build_decl (CONST_DECL, name, type);
12835
12836   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
12837   DECL_INITIAL (decl) = value;
12838   TREE_READONLY (decl) = 1;
12839
12840   if (context && context == current_class_type)
12841     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12842       on the TYPE_FIELDS list for `S'.  (That's so that you can say
12843       things like `S::i' later.)  */
12844     finish_member_declaration (decl);
12845   else
12846     {
12847       pushdecl (decl);
12848       GNU_xref_decl (current_function_decl, decl);
12849     }
12850
12851   /* Add this enumeration constant to the list for this type.  */
12852   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
12853 }
12854
12855 \f
12856 static int function_depth;
12857
12858 /* We're defining DECL.  Make sure that it's type is OK.  */
12859
12860 static void
12861 check_function_type (decl)
12862      tree decl;
12863 {
12864   tree fntype = TREE_TYPE (decl);
12865
12866   /* In a function definition, arg types must be complete.  */
12867   require_complete_types_for_parms (current_function_parms);
12868
12869   if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
12870     {
12871       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
12872
12873       /* Make it return void instead, but don't change the
12874          type of the DECL_RESULT, in case we have a named return value.  */
12875       if (TREE_CODE (fntype) == METHOD_TYPE)
12876         {
12877           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
12878           TREE_TYPE (decl)
12879             = build_cplus_method_type (ctype,
12880                                        void_type_node,
12881                                        FUNCTION_ARG_CHAIN (decl));
12882         }
12883       else
12884         TREE_TYPE (decl)
12885           = build_function_type (void_type_node,
12886                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
12887       TREE_TYPE (decl)
12888         = build_exception_variant (fntype,
12889                                    TYPE_RAISES_EXCEPTIONS (fntype));
12890     }
12891   else
12892     abstract_virtuals_error (decl, TREE_TYPE (fntype));
12893 }
12894
12895 /* Create the FUNCTION_DECL for a function definition.
12896    DECLSPECS and DECLARATOR are the parts of the declaration;
12897    they describe the function's name and the type it returns,
12898    but twisted together in a fashion that parallels the syntax of C.
12899
12900    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12901    DECLARATOR is really the DECL for the function we are about to
12902    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12903    indicating that the function is an inline defined in-class, and
12904    SF_EXPAND indicating that we should generate RTL for this
12905    function.
12906
12907    This function creates a binding context for the function body
12908    as well as setting up the FUNCTION_DECL in current_function_decl.
12909
12910    Returns 1 on success.  If the DECLARATOR is not suitable for a function
12911    (it defines a datum instead), we return 0, which tells
12912    yyparse to report a parse error.
12913
12914    For C++, we must first check whether that datum makes any sense.
12915    For example, "class A local_a(1,2);" means that variable local_a
12916    is an aggregate of type A, which should have a constructor
12917    applied to it with the argument list [1, 2].  */
12918
12919 int
12920 start_function (declspecs, declarator, attrs, flags)
12921      tree declspecs, declarator, attrs;
12922      int flags;
12923 {
12924   tree decl1;
12925   tree ctype = NULL_TREE;
12926   tree fntype;
12927   tree restype;
12928   extern int have_extern_spec;
12929   extern int used_extern_spec;
12930   int doing_friend = 0;
12931   struct binding_level *bl;
12932
12933   /* Sanity check.  */
12934   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
12935   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
12936
12937   /* This should only be done once on the top most decl.  */
12938   if (have_extern_spec && !used_extern_spec)
12939     {
12940       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
12941       used_extern_spec = 1;
12942     }
12943
12944   if (flags & SF_PRE_PARSED)
12945     {
12946       decl1 = declarator;
12947
12948       fntype = TREE_TYPE (decl1);
12949       if (TREE_CODE (fntype) == METHOD_TYPE)
12950         ctype = TYPE_METHOD_BASETYPE (fntype);
12951
12952       /* ISO C++ 11.4/5.  A friend function defined in a class is in
12953          the (lexical) scope of the class in which it is defined.  */
12954       if (!ctype && DECL_FRIEND_P (decl1))
12955         {
12956           ctype = DECL_FRIEND_CONTEXT (decl1);
12957
12958           /* CTYPE could be null here if we're dealing with a template;
12959              for example, `inline friend float foo()' inside a template
12960              will have no CTYPE set.  */
12961           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
12962             ctype = NULL_TREE;
12963           else
12964             doing_friend = 1;
12965         }
12966
12967       last_function_parms = DECL_ARGUMENTS (decl1);
12968       last_function_parm_tags = NULL_TREE;
12969     }
12970   else
12971     {
12972       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
12973       /* If the declarator is not suitable for a function definition,
12974          cause a syntax error.  */
12975       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
12976
12977       fntype = TREE_TYPE (decl1);
12978
12979       restype = TREE_TYPE (fntype);
12980       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
12981         {
12982           cp_error ("semicolon missing after declaration of `%#T'", restype);
12983           shadow_tag (build_tree_list (NULL_TREE, restype));
12984           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
12985           if (TREE_CODE (fntype) == FUNCTION_TYPE)
12986             fntype = build_function_type (integer_type_node,
12987                                           TYPE_ARG_TYPES (fntype));
12988           else
12989             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
12990                                               integer_type_node,
12991                                               TYPE_ARG_TYPES (fntype));
12992           TREE_TYPE (decl1) = fntype;
12993         }
12994
12995       if (TREE_CODE (fntype) == METHOD_TYPE)
12996         ctype = TYPE_METHOD_BASETYPE (fntype);
12997       else if (DECL_MAIN_P (decl1))
12998         {
12999           /* If this doesn't return integer_type, complain.  */
13000           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13001             {
13002               if (pedantic || warn_return_type)
13003                 pedwarn ("return type for `main' changed to `int'");
13004               TREE_TYPE (decl1) = fntype = default_function_type;
13005             }
13006         }
13007     }
13008
13009   /* Sometimes we don't notice that a function is a static member, and
13010      build a METHOD_TYPE for it.  Fix that up now.  */
13011   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13012       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13013     {
13014       revert_static_member_fn (&decl1, NULL, NULL);
13015       last_function_parms = TREE_CHAIN (last_function_parms);
13016       ctype = NULL_TREE;
13017     }
13018
13019   /* Warn if function was previously implicitly declared
13020      (but not if we warned then).  */
13021   if (! warn_implicit
13022       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13023     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13024
13025   /* Set up current_class_type, and enter the scope of the class, if
13026      appropriate.  */
13027   if (ctype)
13028     push_nested_class (ctype, 1);
13029   else if (DECL_STATIC_FUNCTION_P (decl1))
13030     push_nested_class (DECL_CONTEXT (decl1), 2);
13031
13032   /* Now that we have entered the scope of the class, we must restore
13033      the bindings for any template parameters surrounding DECL1, if it
13034      is an inline member template.  (Order is important; consider the
13035      case where a template parameter has the same name as a field of
13036      the class.)  It is not until after this point that
13037      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13038   if (flags & SF_INCLASS_INLINE)
13039     maybe_begin_member_template_processing (decl1);
13040
13041   /* Effective C++ rule 15.  See also c_expand_return.  */
13042   if (warn_ecpp
13043       && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
13044       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13045     cp_warning ("`operator=' should return a reference to `*this'");
13046
13047   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13048      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13049   if (!DECL_INITIAL (decl1))
13050     DECL_INITIAL (decl1) = error_mark_node;
13051
13052 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13053   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13054 #endif
13055
13056   /* This function exists in static storage.
13057      (This does not mean `static' in the C sense!)  */
13058   TREE_STATIC (decl1) = 1;
13059
13060   /* We must call push_template_decl after current_class_type is set
13061      up.  (If we are processing inline definitions after exiting a
13062      class scope, current_class_type will be NULL_TREE until set above
13063      by push_nested_class.)  */
13064   if (processing_template_decl)
13065     decl1 = push_template_decl (decl1);
13066
13067   /* We are now in the scope of the function being defined.  */
13068   current_function_decl = decl1;
13069
13070   /* Save the parm names or decls from this function's declarator
13071      where store_parm_decls will find them.  */
13072   current_function_parms = last_function_parms;
13073   current_function_parm_tags = last_function_parm_tags;
13074
13075   /* Make sure the parameter and return types are reasonable.  When
13076      you declare a function, these types can be incomplete, but they
13077      must be complete when you define the function.  */
13078   if (! processing_template_decl)
13079     check_function_type (decl1);
13080
13081   /* Build the return declaration for the function.  */
13082   restype = TREE_TYPE (fntype);
13083   if (!processing_template_decl)
13084     {
13085       if (!DECL_RESULT (decl1))
13086         {
13087           DECL_RESULT (decl1)
13088             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13089           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13090                                       DECL_RESULT (decl1));
13091         }
13092     }
13093   else
13094     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13095     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13096
13097   /* Initialize RTL machinery.  We cannot do this until
13098      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13099      even when processing a template; this is how we get
13100      CFUN set up, and our per-function variables initialized.  */
13101   bl = current_binding_level;
13102   init_function_start (decl1, input_filename, lineno);
13103   current_binding_level = bl;
13104   expanding_p = (flags & SF_EXPAND) != 0;
13105
13106   /* Even though we're inside a function body, we still don't want to
13107      call expand_expr to calculate the size of a variable-sized array.
13108      We haven't necessarily assigned RTL to all variables yet, so it's
13109      not safe to try to expand expressions involving them.  */
13110   immediate_size_expand = 0;
13111   cfun->x_dont_save_pending_sizes_p = 1;
13112
13113   /* If we're building a statement-tree, start the tree now.  */
13114   if (processing_template_decl || !expanding_p)
13115     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13116
13117   /* Let the user know we're compiling this function.  */
13118   if (processing_template_decl || !building_stmt_tree ())
13119     announce_function (decl1);
13120
13121   /* Record the decl so that the function name is defined.
13122      If we already have a decl for this name, and it is a FUNCTION_DECL,
13123      use the old decl.  */
13124   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13125     {
13126       /* A specialization is not used to guide overload resolution.  */
13127       if ((flag_guiding_decls
13128            || !DECL_TEMPLATE_SPECIALIZATION (decl1))
13129           && ! DECL_FUNCTION_MEMBER_P (decl1))
13130         decl1 = pushdecl (decl1);
13131       else
13132         {
13133           /* We need to set the DECL_CONTEXT. */
13134           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13135             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13136           /* And make sure we have enough default args.  */
13137           check_default_args (decl1);
13138         }
13139       DECL_MAIN_VARIANT (decl1) = decl1;
13140       fntype = TREE_TYPE (decl1);
13141     }
13142
13143   /* Reset these in case the call to pushdecl changed them.  */
13144   current_function_decl = decl1;
13145   cfun->decl = decl1;
13146
13147   /* Initialize the per-function data.  */
13148   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13149     {
13150       /* If we already parsed this function, and we're just expanding it
13151          now, restore saved state.  */
13152       struct binding_level *bl = current_binding_level;
13153       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13154       current_binding_level = bl;
13155
13156       /* This function is being processed in whole-function mode; we
13157          already did semantic analysis.  */
13158       cfun->x_whole_function_mode_p = 1;
13159
13160       /* If we decided that we didn't want to inline this function,
13161          make sure the back-end knows that.  */
13162       if (!current_function_cannot_inline)
13163         current_function_cannot_inline = cp_function_chain->cannot_inline;
13164
13165       /* We don't need the saved data anymore.  */
13166       free (DECL_SAVED_FUNCTION_DATA (decl1));
13167       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13168     }
13169   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13170     {
13171       /* We know that this was set up by `grokclassfn'.  We do not
13172          wait until `store_parm_decls', since evil parse errors may
13173          never get us to that point.  Here we keep the consistency
13174          between `current_class_type' and `current_class_ptr'.  */
13175       tree t = DECL_ARGUMENTS (decl1);
13176
13177       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13178                           162);
13179       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13180                           19990811);
13181
13182       cp_function_chain->x_current_class_ref
13183         = build_indirect_ref (t, NULL_PTR);
13184       cp_function_chain->x_current_class_ptr = t;
13185
13186       /* Constructors and destructors need to know whether they're "in
13187          charge" of initializing virtual base classes.  */
13188       if (DECL_DESTRUCTOR_P (decl1))
13189         current_in_charge_parm = TREE_CHAIN (t);
13190       else if (DECL_CONSTRUCTOR_P (decl1)
13191                && TREE_CHAIN (t)
13192                && DECL_ARTIFICIAL (TREE_CHAIN (t))
13193                && (DECL_NAME (TREE_CHAIN (t))
13194                    == in_charge_identifier))
13195         current_in_charge_parm = TREE_CHAIN (t);
13196     }
13197
13198   if (DECL_INTERFACE_KNOWN (decl1))
13199     {
13200       tree ctx = decl_function_context (decl1);
13201
13202       if (DECL_NOT_REALLY_EXTERN (decl1))
13203         DECL_EXTERNAL (decl1) = 0;
13204
13205       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13206           && TREE_PUBLIC (ctx))
13207         /* This is a function in a local class in an extern inline
13208            function.  */
13209         comdat_linkage (decl1);
13210     }
13211   /* If this function belongs to an interface, it is public.
13212      If it belongs to someone else's interface, it is also external.
13213      This only affects inlines and template instantiations.  */
13214   else if (interface_unknown == 0
13215            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13216                || flag_alt_external_templates))
13217     {
13218       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13219           || processing_template_decl)
13220         {
13221           DECL_EXTERNAL (decl1)
13222             = (interface_only
13223                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13224                    && !DECL_VINDEX (decl1)));
13225
13226           /* For WIN32 we also want to put these in linkonce sections.  */
13227           maybe_make_one_only (decl1);
13228         }
13229       else
13230         DECL_EXTERNAL (decl1) = 0;
13231       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13232       DECL_INTERFACE_KNOWN (decl1) = 1;
13233     }
13234   else if (interface_unknown && interface_only
13235            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13236                || flag_alt_external_templates))
13237     {
13238       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13239          interface, we will have interface_only set but not
13240          interface_known.  In that case, we don't want to use the normal
13241          heuristics because someone will supply a #pragma implementation
13242          elsewhere, and deducing it here would produce a conflict.  */
13243       comdat_linkage (decl1);
13244       DECL_EXTERNAL (decl1) = 0;
13245       DECL_INTERFACE_KNOWN (decl1) = 1;
13246       DECL_DEFER_OUTPUT (decl1) = 1;
13247     }
13248   else
13249     {
13250       /* This is a definition, not a reference.
13251          So clear DECL_EXTERNAL.  */
13252       DECL_EXTERNAL (decl1) = 0;
13253
13254       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13255           && ! DECL_INTERFACE_KNOWN (decl1)
13256           /* Don't try to defer nested functions for now.  */
13257           && ! decl_function_context (decl1))
13258         DECL_DEFER_OUTPUT (decl1) = 1;
13259       else
13260         DECL_INTERFACE_KNOWN (decl1) = 1;
13261     }
13262
13263   if (doing_semantic_analysis_p ())
13264     {
13265       pushlevel (0);
13266       current_binding_level->parm_flag = 1;
13267     }
13268
13269   if (attrs)
13270     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13271
13272   if (!building_stmt_tree ())
13273     {
13274       GNU_xref_function (decl1, current_function_parms);
13275       make_function_rtl (decl1);
13276     }
13277
13278   /* Promote the value to int before returning it.  */
13279   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13280     restype = type_promotes_to (restype);
13281
13282   /* If this fcn was already referenced via a block-scope `extern' decl
13283      (or an implicit decl), propagate certain information about the usage.  */
13284   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13285     TREE_ADDRESSABLE (decl1) = 1;
13286
13287   if (DECL_RESULT (decl1) == NULL_TREE)
13288     {
13289       DECL_RESULT (decl1)
13290         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13291       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13292       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13293     }
13294
13295   ++function_depth;
13296
13297   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
13298       && DECL_LANGUAGE (decl1) == lang_cplusplus)
13299     {
13300       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13301       DECL_CONTEXT (dtor_label) = current_function_decl;
13302     }
13303   else if (DECL_CONSTRUCTOR_P (decl1))
13304     {
13305       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13306       DECL_CONTEXT (ctor_label) = current_function_decl;
13307     }
13308
13309   return 1;
13310 }
13311 \f
13312 /* Called after store_parm_decls for a function-try-block.  */
13313
13314 void
13315 expand_start_early_try_stmts ()
13316 {
13317   expand_start_try_stmts ();
13318 }
13319
13320 /* Store the parameter declarations into the current function declaration.
13321    This is called after parsing the parameter declarations, before
13322    digesting the body of the function.
13323
13324    Also install to binding contour return value identifier, if any.  */
13325
13326 void
13327 store_parm_decls ()
13328 {
13329   register tree fndecl = current_function_decl;
13330   register tree parm;
13331   int parms_have_cleanups = 0;
13332   tree cleanups = NULL_TREE;
13333
13334   /* This is a list of types declared among parms in a prototype.  */
13335   tree parmtags = current_function_parm_tags;
13336
13337   /* This is a chain of any other decls that came in among the parm
13338      declarations.  If a parm is declared with  enum {foo, bar} x;
13339      then CONST_DECLs for foo and bar are put here.  */
13340   tree nonparms = NULL_TREE;
13341
13342   /* Create a binding level for the parms.  */
13343   if (!building_stmt_tree ())
13344     expand_start_bindings (2);
13345
13346   if (current_function_parms)
13347     {
13348       /* This case is when the function was defined with an ANSI prototype.
13349          The parms already have decls, so we need not do anything here
13350          except record them as in effect
13351          and complain if any redundant old-style parm decls were written.  */
13352
13353       tree specparms = current_function_parms;
13354       tree next;
13355
13356       if (doing_semantic_analysis_p ())
13357         {
13358           /* Must clear this because it might contain TYPE_DECLs declared
13359              at class level.  */
13360           storedecls (NULL_TREE);
13361
13362           /* If we're doing semantic analysis, then we'll call pushdecl
13363              for each of these.  We must do them in reverse order so that
13364              they end in the correct forward order.  */
13365           specparms = nreverse (specparms);
13366         }
13367
13368       for (parm = specparms; parm; parm = next)
13369         {
13370           next = TREE_CHAIN (parm);
13371           if (TREE_CODE (parm) == PARM_DECL)
13372             {
13373               tree type = TREE_TYPE (parm);
13374
13375               if (doing_semantic_analysis_p ())
13376                 {
13377                   tree cleanup;
13378
13379                   if (DECL_NAME (parm) == NULL_TREE
13380                       || TREE_CODE (parm) != VOID_TYPE)
13381                     pushdecl (parm);
13382                   else
13383                     cp_error ("parameter `%D' declared void", parm);
13384
13385                   cleanup = (processing_template_decl
13386                              ? NULL_TREE
13387                              : maybe_build_cleanup (parm));
13388
13389                   if (cleanup)
13390                     cleanups = tree_cons (parm, cleanup, cleanups);
13391                 }
13392               else if (type != error_mark_node
13393                        && TYPE_NEEDS_DESTRUCTOR (type))
13394                 parms_have_cleanups = 1;
13395             }
13396           else
13397             {
13398               /* If we find an enum constant or a type tag,
13399                  put it aside for the moment.  */
13400               TREE_CHAIN (parm) = NULL_TREE;
13401               nonparms = chainon (nonparms, parm);
13402             }
13403         }
13404
13405       if (doing_semantic_analysis_p ())
13406         {
13407           /* Get the decls in their original chain order
13408              and record in the function.  This is all and only the
13409              PARM_DECLs that were pushed into scope by the loop above.  */
13410           DECL_ARGUMENTS (fndecl) = getdecls ();
13411           storetags (chainon (parmtags, gettags ()));
13412         }
13413     }
13414   else
13415     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13416
13417   /* Now store the final chain of decls for the arguments
13418      as the decl-chain of the current lexical scope.
13419      Put the enumerators in as well, at the front so that
13420      DECL_ARGUMENTS is not modified.  */
13421   if (doing_semantic_analysis_p ())
13422     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13423
13424   /* Initialize the RTL code for the function.  */
13425   DECL_SAVED_INSNS (fndecl) = 0;
13426   if (! building_stmt_tree ())
13427     expand_function_start (fndecl, parms_have_cleanups);
13428
13429   current_function_parms_stored = 1;
13430
13431   /* If this function is `main', emit a call to `__main'
13432      to run global initializers, etc.  */
13433   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13434     expand_main_function ();
13435
13436   /* Now that we have initialized the parms, we can start their
13437      cleanups.  We cannot do this before, since expand_decl_cleanup
13438      should not be called before the parm can be used.  */
13439   while (cleanups)
13440     {
13441       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13442                            TREE_VALUE (cleanups));
13443       cleanups = TREE_CHAIN (cleanups);
13444     }
13445
13446   /* Create a binding contour which can be used to catch
13447      cleanup-generated temporaries.  Also, if the return value needs or
13448      has initialization, deal with that now.  */
13449   if (parms_have_cleanups)
13450     {
13451       pushlevel (0);
13452       if (!building_stmt_tree ())
13453         expand_start_bindings (2);
13454     }
13455
13456   /* Do the starting of the exception specifications, if we have any.  */
13457   if (flag_exceptions && !processing_template_decl
13458       && building_stmt_tree ()
13459       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13460     current_eh_spec_try_block = expand_start_eh_spec ();
13461 }
13462
13463 /* Bind a name and initialization to the return value of
13464    the current function.  */
13465
13466 void
13467 store_return_init (decl)
13468      tree decl;
13469 {
13470   /* If this named return value comes in a register, put it in a
13471      pseudo-register.  */
13472   if (DECL_REGISTER (decl))
13473     {
13474       original_result_rtx = DECL_RTL (decl);
13475       /* Note that the mode of the old DECL_RTL may be wider than the
13476          mode of DECL_RESULT, depending on the calling conventions for
13477          the processor.  For example, on the Alpha, a 32-bit integer
13478          is returned in a DImode register -- the DECL_RESULT has
13479          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
13480          here, we use the mode the back-end has already assigned for
13481          the return value.  */
13482       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13483     }
13484 }
13485
13486 \f
13487 /* We have finished doing semantic analysis on DECL, but have not yet
13488    generated RTL for its body.  Save away our current state, so that
13489    when we want to generate RTL later we know what to do.  */
13490
13491 static void
13492 save_function_data (decl)
13493      tree decl;
13494 {
13495   struct language_function *f;
13496
13497   /* Save the language-specific per-function data so that we can
13498      get it back when we really expand this function.  */
13499   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13500                       19990908);
13501
13502   /* Make a copy.  */
13503   f = ((struct language_function *)
13504        xmalloc (sizeof (struct language_function)));
13505   bcopy ((char *) cp_function_chain, (char *) f,
13506          sizeof (struct language_function));
13507   DECL_SAVED_FUNCTION_DATA (decl) = f;
13508
13509   /* Clear out the bits we don't need.  */
13510   f->x_base_init_list = NULL_TREE;
13511   f->x_member_init_list = NULL_TREE;
13512   f->x_stmt_tree.x_last_stmt = NULL_TREE;
13513   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
13514   f->x_result_rtx = NULL_RTX;
13515   f->x_named_label_uses = NULL;
13516   f->bindings = NULL;
13517
13518   /* When we get back here again, we will be expanding.  */
13519   f->x_expanding_p = 1;
13520
13521   /* If we've already decided that we cannot inline this function, we
13522      must remember that fact when we actually go to expand the
13523      function.  */
13524   f->cannot_inline = current_function_cannot_inline;
13525 }
13526
13527 /* At the end of every constructor we generate to code to return
13528    `this'.  Do that now.  */
13529
13530 static void
13531 finish_constructor_body ()
13532 {
13533   /* Any return from a constructor will end up here.  */
13534   add_tree (build_min_nt (LABEL_STMT, ctor_label));
13535
13536   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13537      generate the return, rather than a goto to CTOR_LABEL.  */
13538   ctor_label = NULL_TREE;
13539   /* In check_return_expr we translate an empty return from a
13540      constructor to a return of `this'.  */
13541   finish_return_stmt (NULL_TREE);
13542   /* Mark the end of the constructor.  */
13543   add_tree (build_min_nt (CTOR_STMT));
13544 }
13545
13546 /* At the end of every destructor we generate code to restore virtual
13547    function tables to the values desired by base classes and to call
13548    to base class destructors.  Do that now.  */
13549
13550 static void
13551 finish_destructor_body ()
13552 {
13553   tree compound_stmt;
13554   tree in_charge;
13555   tree virtual_size;
13556   tree exprstmt;
13557
13558   /* Create a block to contain all the extra code.  */
13559   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13560
13561   /* Any return from a destructor will end up here.  */
13562   add_tree (build_min_nt (LABEL_STMT, dtor_label));
13563
13564   /* Generate the code to call destructor on base class.  If this
13565      destructor belongs to a class with virtual functions, then set
13566      the virtual function table pointer to represent the type of our
13567      base class.  */
13568
13569   /* This side-effect makes call to `build_delete' generate the code
13570      we have to have at the end of this destructor.  `build_delete'
13571      will set the flag again.  */
13572   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13573
13574   /* These are two cases where we cannot delegate deletion.  */
13575   if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
13576       || TYPE_GETS_REG_DELETE (current_class_type))
13577     in_charge = integer_zero_node;
13578   else
13579     in_charge = current_in_charge_parm;
13580
13581   exprstmt = build_delete (current_class_type,
13582                            current_class_ref,
13583                            in_charge,
13584                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13585                            0);
13586
13587   if (exprstmt != error_mark_node
13588       && (TREE_CODE (exprstmt) != NOP_EXPR
13589           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13590           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13591     {
13592       if (exprstmt != void_zero_node)
13593         /* Don't call `expand_expr_stmt' if we're not going to do
13594            anything, since -Wall will give a diagnostic.  */
13595         finish_expr_stmt (exprstmt);
13596
13597       /* Run destructors for all virtual baseclasses.  */
13598       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13599         {
13600           tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
13601           tree if_stmt = begin_if_stmt ();
13602           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13603                                       current_in_charge_parm,
13604                                       integer_two_node),
13605                                if_stmt);
13606
13607           while (vbases)
13608             {
13609               if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases)))
13610                 {
13611                   tree vb = get_vbase
13612                     (BINFO_TYPE (vbases),
13613                      TYPE_BINFO (current_class_type));
13614                   finish_expr_stmt
13615                     (build_scoped_method_call
13616                      (current_class_ref, vb, dtor_identifier,
13617                       build_tree_list (NULL_TREE, integer_zero_node)));
13618                 }
13619               vbases = TREE_CHAIN (vbases);
13620             }
13621
13622           finish_then_clause (if_stmt);
13623           finish_if_stmt ();
13624         }
13625     }
13626
13627   virtual_size = c_sizeof (current_class_type);
13628
13629   /* At the end, call delete if that's what's requested.  */
13630
13631   /* FDIS sez: At the point of definition of a virtual destructor
13632      (including an implicit definition), non-placement operator delete
13633      shall be looked up in the scope of the destructor's class and if
13634      found shall be accessible and unambiguous.
13635
13636      This is somewhat unclear, but I take it to mean that if the class
13637      only defines placement deletes we don't do anything here.  So we
13638      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13639      they ever try to delete one of these.  */
13640   if (TYPE_GETS_REG_DELETE (current_class_type)
13641       || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13642     {
13643       tree if_stmt;
13644
13645       exprstmt = build_op_delete_call
13646         (DELETE_EXPR, current_class_ptr, virtual_size,
13647          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13648
13649       if_stmt = begin_if_stmt ();
13650       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13651                                   current_in_charge_parm,
13652                                   integer_one_node),
13653                            if_stmt);
13654       finish_expr_stmt (exprstmt);
13655       finish_then_clause (if_stmt);
13656       finish_if_stmt ();
13657     }
13658
13659   /* Close the block we started above.  */
13660   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13661 }
13662
13663 /* Finish up a function declaration and compile that function
13664    all the way to assembler language output.  The free the storage
13665    for the function definition.
13666
13667    This is called after parsing the body of the function definition.
13668    LINENO is the current line number.
13669
13670    FLAGS is a bitwise or of the following values:
13671      1 - CALL_POPLEVEL
13672        An extra call to poplevel (and expand_end_bindings) must be
13673        made to take care of the binding contour for the base
13674        initializers.  This is only relevant for constructors.
13675      2 - INCLASS_INLINE
13676        We just finished processing the body of an in-class inline
13677        function definition.  (This processing will have taken place
13678        after the class definition is complete.)  */
13679
13680 tree
13681 finish_function (lineno, flags)
13682      int lineno;
13683      int flags;
13684 {
13685   register tree fndecl = current_function_decl;
13686   tree fntype, ctype = NULL_TREE;
13687   /* Label to use if this function is supposed to return a value.  */
13688   tree no_return_label = NULL_TREE;
13689   int call_poplevel = (flags & 1) != 0;
13690   int inclass_inline = (flags & 2) != 0;
13691   int expand_p;
13692   int nested;
13693
13694   /* When we get some parse errors, we can end up without a
13695      current_function_decl, so cope.  */
13696   if (fndecl == NULL_TREE)
13697     return error_mark_node;
13698
13699   nested = function_depth > 1;
13700   fntype = TREE_TYPE (fndecl);
13701
13702   /*  TREE_READONLY (fndecl) = 1;
13703       This caused &foo to be of type ptr-to-const-function
13704       which then got a warning when stored in a ptr-to-function variable.  */
13705
13706   /* This happens on strange parse errors.  */
13707   if (! current_function_parms_stored)
13708     {
13709       call_poplevel = 0;
13710       store_parm_decls ();
13711     }
13712
13713   if (building_stmt_tree ())
13714     {
13715       if (DECL_CONSTRUCTOR_P (fndecl))
13716         {
13717           finish_constructor_body ();
13718           if (call_poplevel)
13719             do_poplevel ();
13720         }
13721       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13722         finish_destructor_body ();
13723       else if (DECL_MAIN_P (fndecl))
13724         {
13725           /* Make it so that `main' always returns 0 by default.  */
13726 #ifdef VMS
13727           finish_return_stmt (integer_one_node);
13728 #else
13729           finish_return_stmt (integer_zero_node);
13730 #endif
13731         }
13732
13733       /* Finish dealing with exception specifiers.  */
13734       if (flag_exceptions && !processing_template_decl
13735           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13736         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13737                             (TREE_TYPE (current_function_decl)),
13738                             current_eh_spec_try_block);
13739     }
13740   else
13741     {
13742 #if 0
13743       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13744         {
13745           /* Keep this code around in case we later want to control debug info
13746              based on whether a type is "used".  (jason 1999-11-11) */
13747
13748           tree ttype = target_type (fntype);
13749           tree parmdecl;
13750
13751           if (IS_AGGR_TYPE (ttype))
13752             /* Let debugger know it should output info for this type.  */
13753             note_debug_info_needed (ttype);
13754
13755           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
13756             {
13757               ttype = target_type (TREE_TYPE (parmdecl));
13758               if (IS_AGGR_TYPE (ttype))
13759                 /* Let debugger know it should output info for this type.  */
13760                 note_debug_info_needed (ttype);
13761             }
13762         }
13763 #endif
13764
13765       /* Clean house because we will need to reorder insns here.  */
13766       do_pending_stack_adjust ();
13767
13768       if (dtor_label)
13769         ;
13770       else if (DECL_CONSTRUCTOR_P (fndecl))
13771         {
13772           if (call_poplevel)
13773             do_poplevel ();
13774         }
13775       else if (return_label != NULL_RTX
13776                && flag_this_is_variable <= 0
13777                && current_function_return_value == NULL_TREE
13778                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
13779         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13780
13781       if (flag_exceptions)
13782         expand_exception_blocks ();
13783
13784       /* If this function is supposed to return a value, ensure that
13785          we do not fall into the cleanups by mistake.  The end of our
13786          function will look like this:
13787
13788          user code (may have return stmt somewhere)
13789          goto no_return_label
13790          cleanup_label:
13791          cleanups
13792          goto return_label
13793          no_return_label:
13794          NOTE_INSN_FUNCTION_END
13795          return_label:
13796          things for return
13797
13798          If the user omits a return stmt in the USER CODE section, we
13799          will have a control path which reaches NOTE_INSN_FUNCTION_END.
13800          Otherwise, we won't.  */
13801       if (no_return_label)
13802         {
13803           DECL_CONTEXT (no_return_label) = fndecl;
13804           DECL_INITIAL (no_return_label) = error_mark_node;
13805           DECL_SOURCE_FILE (no_return_label) = input_filename;
13806           DECL_SOURCE_LINE (no_return_label) = lineno;
13807           expand_goto (no_return_label);
13808         }
13809
13810       if (cleanup_label)
13811         {
13812           /* Remove the binding contour which is used
13813              to catch cleanup-generated temporaries.  */
13814           expand_end_bindings (0, 0, 0);
13815           poplevel (0, 0, 0);
13816
13817           /* Emit label at beginning of cleanup code for parameters.  */
13818           emit_label (cleanup_label);
13819         }
13820
13821       /* Get return value into register if that's where it's supposed
13822          to be.  */
13823       if (original_result_rtx)
13824         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
13825
13826       /* Finish building code that will trigger warnings if users forget
13827          to make their functions return values.  */
13828       if (no_return_label || cleanup_label)
13829         emit_jump (return_label);
13830       if (no_return_label)
13831         {
13832           /* We don't need to call `expand_*_return' here because we
13833              don't need any cleanups here--this path of code is only
13834              for error checking purposes.  */
13835           expand_label (no_return_label);
13836         }
13837
13838       /* We hard-wired immediate_size_expand to zero in
13839          start_function.  Expand_function_end will decrement this
13840          variable.  So, we set the variable to one here, so that after
13841          the decrement it will remain zero.  */
13842       immediate_size_expand = 1;
13843
13844       /* Generate rtl for function exit.  */
13845       expand_function_end (input_filename, lineno, 1);
13846     }
13847
13848   /* We have to save this value here in case
13849      maybe_end_member_template_processing decides to pop all the
13850      template parameters.  */
13851   expand_p = !building_stmt_tree ();
13852
13853   /* If we're saving up tree structure, tie off the function now.  */
13854   if (!expand_p)
13855     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13856
13857   /* This must come after expand_function_end because cleanups might
13858      have declarations (from inline functions) that need to go into
13859      this function's blocks.  */
13860   if (doing_semantic_analysis_p ())
13861     {
13862       if (current_binding_level->parm_flag != 1)
13863         my_friendly_abort (122);
13864       poplevel (1, 0, 1);
13865     }
13866
13867   /* Remember that we were in class scope.  */
13868   if (current_class_name)
13869     ctype = current_class_type;
13870
13871   /* Must mark the RESULT_DECL as being in this function.  */
13872   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13873
13874   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13875      to the FUNCTION_DECL node itself.  */
13876   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13877
13878   /* Save away current state, if appropriate.  */
13879   if (!expanding_p && !processing_template_decl)
13880     save_function_data (fndecl);
13881
13882   /* If this function calls `setjmp' it cannot be inlined.  When
13883      `longjmp' is called it is not guaranteed to restore the value of
13884      local variables that have been modified since the call to
13885      `setjmp'.  So, if were to inline this function into some caller
13886      `c', then when we `longjmp', we might not restore all variables
13887      in `c'.  (It might seem, at first blush, that there's no way for
13888      this function to modify local variables in `c', but their
13889      addresses may have been stored somewhere accessible to this
13890      function.)  */
13891   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
13892     DECL_UNINLINABLE (fndecl) = 1;
13893
13894   if (expand_p)
13895     {
13896       int returns_null;
13897       int returns_value;
13898       int saved_flag_keep_inline_functions =
13899         flag_keep_inline_functions;
13900
13901       /* So we can tell if jump_optimize sets it to 1.  */
13902       can_reach_end = 0;
13903
13904       if (DECL_CONTEXT (fndecl) != NULL_TREE
13905           && decl_function_context (fndecl))
13906         /* Trick rest_of_compilation into not deferring output of this
13907            function, even if it is inline, since the rtl_obstack for
13908            this function is the function_obstack of the enclosing
13909            function and will be deallocated when the enclosing
13910            function is gone.  See save_tree_status.  */
13911         flag_keep_inline_functions = 1;
13912
13913       /* Before we call rest_of_compilation (which will pop the
13914          CURRENT_FUNCTION), we must save these values.  */
13915       returns_null = current_function_returns_null;
13916       returns_value = current_function_returns_value;
13917
13918       /* If this is a nested function (like a template instantiation
13919          that we're compiling in the midst of compiling something
13920          else), push a new GC context.  That will keep local variables
13921          on the stack from being collected while we're doing the
13922          compilation of this function.  */
13923       if (function_depth > 1)
13924         ggc_push_context ();
13925
13926       /* Run the optimizers and output the assembler code for this
13927          function.  */
13928       if (DECL_ARTIFICIAL (fndecl))
13929         {
13930           /* Do we really *want* to inline this synthesized method?  */
13931
13932           int save_fif = flag_inline_functions;
13933           flag_inline_functions = 1;
13934
13935           /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13936              will check our size.  */
13937           DECL_INLINE (fndecl) = 0;
13938
13939           rest_of_compilation (fndecl);
13940           flag_inline_functions = save_fif;
13941         }
13942       else
13943         rest_of_compilation (fndecl);
13944
13945       /* Undo the call to ggc_push_context above.  */
13946       if (function_depth > 1)
13947         ggc_pop_context ();
13948
13949       flag_keep_inline_functions = saved_flag_keep_inline_functions;
13950
13951       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
13952         {
13953           /* Set DECL_EXTERNAL so that assemble_external will be called as
13954              necessary.  We'll clear it again in finish_file.  */
13955           if (! DECL_EXTERNAL (fndecl))
13956             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
13957           DECL_EXTERNAL (fndecl) = 1;
13958           mark_inline_for_output (fndecl);
13959         }
13960
13961 #if 0
13962       /* Keep this code around in case we later want to control debug info
13963          based on whether a type is "used".  (jason 1999-11-11) */
13964
13965       if (ctype && TREE_ASM_WRITTEN (fndecl))
13966         note_debug_info_needed (ctype);
13967 #endif
13968
13969       returns_null |= can_reach_end;
13970
13971       /* Since we don't normally go through c_expand_return for constructors,
13972          this normally gets the wrong value.
13973          Also, named return values have their return codes emitted after
13974          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
13975       if (DECL_CONSTRUCTOR_P (fndecl)
13976           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
13977         returns_null = 0;
13978
13979       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
13980         cp_warning ("`noreturn' function `%D' does return", fndecl);
13981       else if ((warn_return_type || pedantic)
13982                && returns_null
13983                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
13984         {
13985           /* If this function returns non-void and control can drop through,
13986              complain.  */
13987           cp_warning ("control reaches end of non-void function `%D'", fndecl);
13988         }
13989       /* With just -W, complain only if function returns both with
13990          and without a value.  */
13991       else if (extra_warnings && returns_value && returns_null)
13992         warning ("this function may return with or without a value");
13993     }
13994   else
13995     {
13996       /* Clear out memory we no longer need.  */
13997       free_after_parsing (cfun);
13998       /* Since we never call rest_of_compilation, we never clear
13999          CFUN.  Do so explicitly.  */
14000       free_after_compilation (cfun);
14001       cfun = NULL;
14002     }
14003
14004   /* If this is a in-class inline definition, we may have to pop the
14005      bindings for the template parameters that we added in
14006      maybe_begin_member_template_processing when start_function was
14007      called.  */
14008   if (inclass_inline)
14009     maybe_end_member_template_processing ();
14010
14011   /* Leave the scope of the class.  */
14012   if (ctype)
14013     pop_nested_class ();
14014
14015   --function_depth;
14016
14017   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14018       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14019     {
14020       tree t;
14021
14022       /* Stop pointing to the local nodes about to be freed.  */
14023       /* But DECL_INITIAL must remain nonzero so we know this
14024          was an actual function definition.  */
14025       DECL_INITIAL (fndecl) = error_mark_node;
14026       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14027         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14028     }
14029
14030   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14031     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14032   if (DECL_STATIC_DESTRUCTOR (fndecl))
14033     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14034
14035   /* Clean up.  */
14036   if (! nested)
14037     {
14038       /* Let the error reporting routines know that we're outside a
14039          function.  For a nested function, this value is used in
14040          pop_cp_function_context and then reset via pop_function_context.  */
14041       current_function_decl = NULL_TREE;
14042       /* We don't really care about obstacks, but the middle-end
14043          sometimes cares on what obstck things are located.  */
14044       permanent_allocation (1);
14045     }
14046
14047   return fndecl;
14048 }
14049 \f
14050 /* Create the FUNCTION_DECL for a function definition.
14051    DECLSPECS and DECLARATOR are the parts of the declaration;
14052    they describe the return type and the name of the function,
14053    but twisted together in a fashion that parallels the syntax of C.
14054
14055    This function creates a binding context for the function body
14056    as well as setting up the FUNCTION_DECL in current_function_decl.
14057
14058    Returns a FUNCTION_DECL on success.
14059
14060    If the DECLARATOR is not suitable for a function (it defines a datum
14061    instead), we return 0, which tells yyparse to report a parse error.
14062
14063    May return void_type_node indicating that this method is actually
14064    a friend.  See grokfield for more details.
14065
14066    Came here with a `.pushlevel' .
14067
14068    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14069    CHANGES TO CODE IN `grokfield'.  */
14070
14071 tree
14072 start_method (declspecs, declarator, attrlist)
14073      tree declarator, declspecs, attrlist;
14074 {
14075   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14076                                 attrlist);
14077
14078   /* Something too ugly to handle.  */
14079   if (fndecl == NULL_TREE)
14080     return NULL_TREE;
14081
14082   /* Pass friends other than inline friend functions back.  */
14083   if (fndecl == void_type_node)
14084     return fndecl;
14085
14086   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14087     /* Not a function, tell parser to report parse error.  */
14088     return NULL_TREE;
14089
14090   if (DECL_IN_AGGR_P (fndecl))
14091     {
14092       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14093         {
14094           if (DECL_CONTEXT (fndecl)
14095               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14096             cp_error ("`%D' is already defined in class %s", fndecl,
14097                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14098         }
14099       return void_type_node;
14100     }
14101
14102   check_template_shadow (fndecl);
14103
14104   DECL_THIS_INLINE (fndecl) = 1;
14105
14106   if (flag_default_inline)
14107     DECL_INLINE (fndecl) = 1;
14108
14109   /* We process method specializations in finish_struct_1.  */
14110   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14111     fndecl = push_template_decl (fndecl);
14112
14113   /* We read in the parameters on the maybepermanent_obstack,
14114      but we won't be getting back to them until after we
14115      may have clobbered them.  So the call to preserve_data
14116      will keep them safe.  */
14117   preserve_data ();
14118
14119   if (! DECL_FRIEND_P (fndecl))
14120     {
14121       if (TREE_CHAIN (fndecl))
14122         {
14123           fndecl = copy_node (fndecl);
14124           TREE_CHAIN (fndecl) = NULL_TREE;
14125         }
14126
14127       if (DECL_CONSTRUCTOR_P (fndecl))
14128         {
14129           if (! grok_ctor_properties (current_class_type, fndecl))
14130             return void_type_node;
14131         }
14132       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14133         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14134     }
14135
14136   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14137
14138   /* Make a place for the parms */
14139   pushlevel (0);
14140   current_binding_level->parm_flag = 1;
14141
14142   DECL_IN_AGGR_P (fndecl) = 1;
14143   return fndecl;
14144 }
14145
14146 /* Go through the motions of finishing a function definition.
14147    We don't compile this method until after the whole class has
14148    been processed.
14149
14150    FINISH_METHOD must return something that looks as though it
14151    came from GROKFIELD (since we are defining a method, after all).
14152
14153    This is called after parsing the body of the function definition.
14154    STMTS is the chain of statements that makes up the function body.
14155
14156    DECL is the ..._DECL that `start_method' provided.  */
14157
14158 tree
14159 finish_method (decl)
14160      tree decl;
14161 {
14162   register tree fndecl = decl;
14163   tree old_initial;
14164
14165   register tree link;
14166
14167   if (decl == void_type_node)
14168     return decl;
14169
14170   old_initial = DECL_INITIAL (fndecl);
14171
14172   /* Undo the level for the parms (from start_method).
14173      This is like poplevel, but it causes nothing to be
14174      saved.  Saving information here confuses symbol-table
14175      output routines.  Besides, this information will
14176      be correctly output when this method is actually
14177      compiled.  */
14178
14179   /* Clear out the meanings of the local variables of this level;
14180      also record in each decl which block it belongs to.  */
14181
14182   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14183     {
14184       if (DECL_NAME (link) != NULL_TREE)
14185         pop_binding (DECL_NAME (link), link);
14186       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14187       DECL_CONTEXT (link) = NULL_TREE;
14188     }
14189
14190   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14191                       (HOST_WIDE_INT) current_binding_level->level_chain,
14192                       current_binding_level->parm_flag,
14193                       current_binding_level->keep);
14194
14195   poplevel (0, 0, 0);
14196
14197   DECL_INITIAL (fndecl) = old_initial;
14198
14199   /* We used to check if the context of FNDECL was different from
14200      current_class_type as another way to get inside here.  This didn't work
14201      for String.cc in libg++.  */
14202   if (DECL_FRIEND_P (fndecl))
14203     {
14204       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14205         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14206       decl = void_type_node;
14207     }
14208
14209   return decl;
14210 }
14211 \f
14212 /* Called when a new struct TYPE is defined.
14213    If this structure or union completes the type of any previous
14214    variable declaration, lay it out and output its rtl.  */
14215
14216 void
14217 hack_incomplete_structures (type)
14218      tree type;
14219 {
14220   tree *list;
14221   struct binding_level *level;
14222
14223   if (!type) /* Don't do this for class templates.  */
14224     return;
14225
14226   if (namespace_bindings_p ())
14227     {
14228       level = 0;
14229       list = &namespace_scope_incomplete;
14230     }
14231   else
14232     {
14233       level = innermost_nonclass_level ();
14234       list = &level->incomplete;
14235     }
14236
14237   while (1)
14238     {
14239       while (*list)
14240         {
14241           tree decl = TREE_VALUE (*list);
14242           if ((decl && TREE_TYPE (decl) == type)
14243               || (TREE_TYPE (decl)
14244                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14245                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14246             {
14247               int toplevel = toplevel_bindings_p ();
14248               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14249                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14250                 layout_type (TREE_TYPE (decl));
14251               layout_decl (decl, 0);
14252               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14253               if (! toplevel)
14254                 {
14255                   tree cleanup;
14256                   expand_decl (decl);
14257                   cleanup = maybe_build_cleanup (decl);
14258                   expand_decl_init (decl);
14259                   if (! expand_decl_cleanup (decl, cleanup))
14260                     cp_error ("parser lost in parsing declaration of `%D'",
14261                               decl);
14262                 }
14263               *list = TREE_CHAIN (*list);
14264             }
14265           else
14266             list = &TREE_CHAIN (*list);
14267         }
14268
14269       /* Keep looking through artificial binding levels generated
14270          for local variables.  */
14271       if (level && level->keep == 2)
14272         {
14273           level = level->level_chain;
14274           list = &level->incomplete;
14275         }
14276       else
14277         break;
14278     }
14279 }
14280
14281 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14282    See build_delete for information about AUTO_DELETE.
14283
14284    Don't build these on the momentary obstack; they must live
14285    the life of the binding contour.  */
14286
14287 static tree
14288 maybe_build_cleanup_1 (decl, auto_delete)
14289      tree decl, auto_delete;
14290 {
14291   tree type = TREE_TYPE (decl);
14292   if (type != error_mark_node && TYPE_NEEDS_DESTRUCTOR (type))
14293     {
14294       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14295       tree rval;
14296
14297       if (TREE_CODE (type) == ARRAY_TYPE)
14298         rval = decl;
14299       else
14300         {
14301           mark_addressable (decl);
14302           rval = build_unary_op (ADDR_EXPR, decl, 0);
14303         }
14304
14305       /* Optimize for space over speed here.  */
14306       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14307           || flag_expensive_optimizations)
14308         flags |= LOOKUP_NONVIRTUAL;
14309
14310       rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
14311
14312       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14313           && ! TYPE_HAS_DESTRUCTOR (type))
14314         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14315                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14316
14317       return rval;
14318     }
14319   return 0;
14320 }
14321
14322 /* If DECL is of a type which needs a cleanup, build that cleanup
14323    here.  The cleanup does free the storage with a call to delete.  */
14324
14325 tree
14326 maybe_build_cleanup_and_delete (decl)
14327      tree decl;
14328 {
14329   return maybe_build_cleanup_1 (decl, integer_three_node);
14330 }
14331
14332 /* If DECL is of a type which needs a cleanup, build that cleanup
14333    here.  The cleanup does not free the storage with a call a delete.  */
14334
14335 tree
14336 maybe_build_cleanup (decl)
14337      tree decl;
14338 {
14339   return maybe_build_cleanup_1 (decl, integer_two_node);
14340 }
14341 \f
14342 /* Expand a C++ expression at the statement level.
14343    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14344    The C++ type checker should get all of these out when
14345    expressions are combined with other, type-providing, expressions,
14346    leaving only orphan expressions, such as:
14347
14348    &class::bar;         / / takes its address, but does nothing with it.  */
14349
14350 void
14351 cplus_expand_expr_stmt (exp)
14352      tree exp;
14353 {
14354   if (stmts_are_full_exprs_p)
14355     exp = convert_to_void (exp, "statement");
14356
14357 #if 0
14358   /* We should do this eventually, but right now this causes regex.o from
14359      libg++ to miscompile, and tString to core dump.  */
14360   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14361 #endif
14362
14363   /* If we don't do this, we end up down inside expand_expr
14364      trying to do TYPE_MODE on the ERROR_MARK, and really
14365      go outside the bounds of the type.  */
14366   if (exp != error_mark_node)
14367     expand_expr_stmt (exp);
14368 }
14369
14370 /* When a stmt has been parsed, this function is called.  */
14371
14372 void
14373 finish_stmt ()
14374 {
14375   /* Always assume this statement was not an expression statement.  If
14376      it actually was an expression statement, its our callers
14377      responsibility to fix this up.  */
14378   last_expr_type = NULL_TREE;
14379 }
14380
14381 /* Change a static member function definition into a FUNCTION_TYPE, instead
14382    of the METHOD_TYPE that we create when it's originally parsed.
14383
14384    WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
14385    (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
14386    other decls.  Either pass the addresses of local variables or NULL.  */
14387
14388 void
14389 revert_static_member_fn (decl, fn, argtypes)
14390      tree *decl, *fn, *argtypes;
14391 {
14392   tree tmp;
14393   tree function = fn ? *fn : TREE_TYPE (*decl);
14394   tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
14395
14396   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14397       != TYPE_UNQUALIFIED)
14398     cp_error ("static member function `%#D' declared with type qualifiers",
14399               *decl);
14400
14401   args = TREE_CHAIN (args);
14402   tmp = build_function_type (TREE_TYPE (function), args);
14403   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14404   tmp = build_exception_variant (tmp,
14405                                  TYPE_RAISES_EXCEPTIONS (function));
14406   TREE_TYPE (*decl) = tmp;
14407   if (DECL_ARGUMENTS (*decl))
14408     DECL_ARGUMENTS (*decl) = TREE_CHAIN (DECL_ARGUMENTS (*decl));
14409   DECL_STATIC_FUNCTION_P (*decl) = 1;
14410   if (fn)
14411     *fn = tmp;
14412   if (argtypes)
14413     *argtypes = args;
14414 }
14415
14416 /* Initialize the variables used during compilation of a C++
14417    function.  */
14418
14419 static void
14420 push_cp_function_context (f)
14421      struct function *f;
14422 {
14423   struct language_function *p
14424     = ((struct language_function *)
14425        xcalloc (1, sizeof (struct language_function)));
14426   f->language = p;
14427
14428   /* It takes an explicit call to expand_body to generate RTL for a
14429      function.  */
14430   expanding_p = 0;
14431
14432   /* Whenever we start a new function, we destroy temporaries in the
14433      usual way.  */
14434   stmts_are_full_exprs_p = 1;
14435 }
14436
14437 /* Free the language-specific parts of F, now that we've finished
14438    compiling the function.  */
14439
14440 static void
14441 pop_cp_function_context (f)
14442      struct function *f;
14443 {
14444   if (f->language)
14445     free (f->language);
14446   f->language = 0;
14447 }
14448
14449 /* Mark P for GC.  */
14450
14451 static void
14452 mark_lang_function (p)
14453      struct language_function *p;
14454 {
14455   if (!p)
14456     return;
14457
14458   ggc_mark_tree (p->x_named_labels);
14459   ggc_mark_tree (p->x_ctor_label);
14460   ggc_mark_tree (p->x_dtor_label);
14461   ggc_mark_tree (p->x_base_init_list);
14462   ggc_mark_tree (p->x_member_init_list);
14463   ggc_mark_tree (p->x_current_class_ptr);
14464   ggc_mark_tree (p->x_current_class_ref);
14465   ggc_mark_tree (p->x_eh_spec_try_block);
14466   ggc_mark_tree (p->x_scope_stmt_stack);
14467
14468   ggc_mark_rtx (p->x_result_rtx);
14469
14470   mark_stmt_tree (&p->x_stmt_tree);
14471   mark_binding_level (&p->bindings);
14472 }
14473
14474 /* Mark the language-specific data in F for GC.  */
14475
14476 static void
14477 mark_cp_function_context (f)
14478      struct function *f;
14479 {
14480   mark_lang_function (f->language);
14481 }
14482
14483 int
14484 in_function_p ()
14485 {
14486   return function_depth != 0;
14487 }
14488
14489
14490 void
14491 lang_mark_false_label_stack (l)
14492      struct label_node *l;
14493 {
14494   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14495   my_friendly_assert (l == NULL, 19990904);
14496 }
14497
14498 void
14499 lang_mark_tree (t)
14500      tree t;
14501 {
14502   enum tree_code code = TREE_CODE (t);
14503   if (code == IDENTIFIER_NODE)
14504     {
14505       struct lang_identifier *li = (struct lang_identifier *) t;
14506       struct lang_id2 *li2 = li->x;
14507       ggc_mark_tree (li->namespace_bindings);
14508       ggc_mark_tree (li->bindings);
14509       ggc_mark_tree (li->class_value);
14510       ggc_mark_tree (li->class_template_info);
14511
14512       if (li2)
14513         {
14514           ggc_mark_tree (li2->label_value);
14515           ggc_mark_tree (li2->implicit_decl);
14516           ggc_mark_tree (li2->error_locus);
14517         }
14518     }
14519   else if (code == CPLUS_BINDING)
14520     {
14521       if (BINDING_HAS_LEVEL_P (t))
14522         mark_binding_level (&BINDING_LEVEL (t));
14523       else
14524         ggc_mark_tree (BINDING_SCOPE (t));
14525       ggc_mark_tree (BINDING_VALUE (t));
14526     }
14527   else if (code == OVERLOAD)
14528     ggc_mark_tree (OVL_FUNCTION (t));
14529   else if (code == TEMPLATE_PARM_INDEX)
14530     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14531   else if (TREE_CODE_CLASS (code) == 'd')
14532     {
14533       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14534
14535       if (ld)
14536         {
14537           ggc_mark (ld);
14538           if (!DECL_GLOBAL_CTOR_P (t) && !DECL_GLOBAL_DTOR_P (t))
14539             ggc_mark_tree (ld->decl_flags.u2.access);
14540           ggc_mark_tree (ld->decl_flags.context);
14541           if (TREE_CODE (t) != NAMESPACE_DECL)
14542             ggc_mark_tree (ld->decl_flags.u.template_info);
14543           else
14544             mark_binding_level (&NAMESPACE_LEVEL (t));
14545           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14546             {
14547               ggc_mark_tree (ld->main_decl_variant);
14548               ggc_mark_tree (ld->befriending_classes);
14549               ggc_mark_tree (ld->saved_tree);
14550               if (TREE_CODE (t) == TYPE_DECL)
14551                 ggc_mark_tree (ld->u.sorted_fields);
14552               else if (TREE_CODE (t) == FUNCTION_DECL
14553                        && !DECL_PENDING_INLINE_P (t))
14554                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14555             }
14556         }
14557     }
14558   else if (TREE_CODE_CLASS (code) == 't')
14559     {
14560       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14561
14562       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14563                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14564         {
14565           ggc_mark (lt);
14566           ggc_mark_tree (lt->vfields);
14567           ggc_mark_tree (lt->vbases);
14568           ggc_mark_tree (lt->tags);
14569           ggc_mark_tree (lt->search_slot);
14570           ggc_mark_tree (lt->size);
14571           ggc_mark_tree (lt->pure_virtuals);
14572           ggc_mark_tree (lt->friend_classes);
14573           ggc_mark_tree (lt->rtti);
14574           ggc_mark_tree (lt->methods);
14575           ggc_mark_tree (lt->template_info);
14576           ggc_mark_tree (lt->befriending_classes);
14577         }
14578       else if (lt)
14579         /* In the case of pointer-to-member function types, the
14580            TYPE_LANG_SPECIFIC is really just a tree.  */
14581         ggc_mark_tree ((tree) lt);
14582     }
14583 }