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 int ambi_op_p PARAMS ((tree));
 117 static int unary_op_p PARAMS ((tree));
 118 static tree store_bindings PARAMS ((tree, tree));
 119 static tree lookup_tag_reverse PARAMS ((tree, tree));
 120 static tree obscure_complex_init PARAMS ((tree, tree));
 121 static tree maybe_build_cleanup_1 PARAMS ((tree, tree));
 122 static tree lookup_name_real PARAMS ((tree, int, int, int));
 123 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 124 static void grok_reference_init PARAMS ((tree, tree, tree));
 125 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 126                               enum overload_flags, tree,
 127                               tree, int, int, int, int, int, int, tree));
 128 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 129 static tree lookup_tag PARAMS ((enum tree_code, tree,
 130                               struct binding_level *, int));
 131 static void set_identifier_type_value_with_scope
 132         PARAMS ((tree, tree, struct binding_level *));
 133 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 134 static void record_unknown_type PARAMS ((tree, const char *));
 135 static tree build_library_fn_1                  PARAMS ((tree, tree));
 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 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 186
 187 #if defined (DEBUG_CP_BINDING_LEVELS)
 188 static void indent PARAMS ((void));
 189 #endif
 190
 191 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 192 tree error_mark_list;
 193
 194 /* The following symbols are subsumed in the cp_global_trees array, and
 195    listed here individually for documentation purposes.
 196
 197    C++ extensions
 198         tree wchar_decl_node;
 199         tree void_zero_node;
 200
 201         tree vtable_entry_type;
 202         tree delta_type_node;
 203 #if 0
 204    Old rtti stuff.
 205         tree __baselist_desc_type_node;
 206         tree __i_desc_type_node, __m_desc_type_node;
 207         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 208 #endif
 209         tree __t_desc_type_node;
 210 #if 0
 211         tree __tp_desc_type_node;
 212 #endif
 213         tree ti_desc_type_node;
 214         tree bltn_desc_type_node, ptr_desc_type_node, ref_desc_type_node;
 215         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 216         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 217         tree ptmd_desc_type_node;
 218         tree base_desc_type_node;
 219 #if 0
 220    Not needed yet?  May be needed one day?
 221         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 222         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 223         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 224 #endif
 225
 226         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 227         tree unknown_type_node;
 228
 229    Array type `vtable_entry_type[]'
 230
 231         tree vtbl_type_node;
 232         tree vtbl_ptr_type_node;
 233
 234    Nnamespace std
 235
 236         tree std_node;
 237
 238    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 239    one that the user will declare, but sufficient to be called
 240    by routines that want to abort the program.
 241
 242         tree abort_fndecl;
 243
 244    The FUNCTION_DECL for the default `::operator delete'.
 245
 246         tree global_delete_fndecl;
 247
 248    Used by RTTI
 249         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 250         tree tinfo_var_id;
 251
 252 */
 253
 254 tree cp_global_trees[CPTI_MAX];
 255
 256 /* Indicates that there is a type value in some namespace, although
 257    that is not necessarily in scope at the moment.  */
 258
 259 static tree global_type_node;
 260
 261 /* Namespace std.  */
 262 int in_std;
 263
 264 /* Expect only namespace names now. */
 265 static int only_namespace_names;
 266
 267 /* If original DECL_RESULT of current function was a register,
 268    but due to being an addressable named return value, would up
 269    on the stack, this variable holds the named return value's
 270    original location.  */
 271
 272 #define original_result_rtx cp_function_chain->x_result_rtx
 273
 274 struct named_label_list
 275 {
 276   struct binding_level *binding_level;
 277   tree names_in_scope;
 278   tree label_decl;
 279   const char *filename_o_goto;
 280   int lineno_o_goto;
 281   struct named_label_list *next;
 282 };
 283
 284 /* Used only for jumps to as-yet undefined labels, since jumps to
 285    defined labels can have their validity checked by stmt.c.  */
 286
 287 #define named_label_uses cp_function_chain->x_named_label_uses
 288
 289 /* A list of objects which have constructors or destructors
 290    which reside in the global scope.  The decl is stored in
 291    the TREE_VALUE slot and the initializer is stored
 292    in the TREE_PURPOSE slot.  */
 293 tree static_aggregates;
 294
 295 /* -- end of C++ */
 296
 297 /* A node for the integer constants 2, and 3.  */
 298
 299 tree integer_two_node, integer_three_node;
 300
 301 /* Parsing a function declarator leaves here a chain of structure
 302    and enum types declared in the parmlist.  */
 303
 304 static tree last_function_parm_tags;
 305
 306 /* Similar, for last_function_parm_tags.  */
 307 tree last_function_parms;
 308 static tree current_function_parm_tags;
 309
 310 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 311    that have names.  Here so we can clear out their names' definitions
 312    at the end of the function.  The TREE_VALUE is a LABEL_DECL; the
 313    TREE_PURPOSE is the previous binding of the label.  */
 314
 315 #define named_labels cp_function_chain->x_named_labels
 316
 317 /* Set to 0 at beginning of a function definition, and whenever
 318    a label (case or named) is defined.  Set to value of expression
 319    returned from function when that value can be transformed into
 320    a named return value.  */
 321
 322 tree current_function_return_value;
 323
 324 /* Nonzero means use the ISO C99 dialect of C.  */
 325
 326 int flag_isoc99;
 327
 328 /* Nonzero means give `double' the same size as `float'.  */
 329
 330 extern int flag_short_double;
 331
 332 /* Nonzero means don't recognize any builtin functions.  */
 333
 334 extern int flag_no_builtin;
 335
 336 /* Nonzero means don't recognize the non-ANSI builtin functions.
 337    -ansi sets this.  */
 338
 339 extern int flag_no_nonansi_builtin;
 340
 341 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
 342    objects.  */
 343 extern int flag_huge_objects;
 344
 345 /* Nonzero if we want to conserve space in the .o files.  We do this
 346    by putting uninitialized data and runtime initialized data into
 347    .common instead of .data at the expense of not flagging multiple
 348    definitions.  */
 349 extern int flag_conserve_space;
 350 \f
 351 /* C and C++ flags are in decl2.c.  */
 352
 353 /* Flag used when debugging spew.c */
 354
 355 extern int spew_debug;
 356
 357 /* A expression of value 0 with the same precision as a sizetype
 358    node, but signed.  */
 359 tree signed_size_zero_node;
 360
 361 /* The name of the anonymous namespace, throughout this translation
 362    unit.  */
 363 tree anonymous_namespace_name;
 364
 365 \f
 366 /* For each binding contour we allocate a binding_level structure
 367    which records the names defined in that contour.
 368    Contours include:
 369     0) the global one
 370     1) one for each function definition,
 371        where internal declarations of the parameters appear.
 372     2) one for each compound statement,
 373        to record its declarations.
 374
 375    The current meaning of a name can be found by searching the levels
 376    from the current one out to the global one.
 377
 378    Off to the side, may be the class_binding_level.  This exists only
 379    to catch class-local declarations.  It is otherwise nonexistent.
 380
 381    Also there may be binding levels that catch cleanups that must be
 382    run when exceptions occur.  Thus, to see whether a name is bound in
 383    the current scope, it is not enough to look in the
 384    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 385    instead.  */
 386
 387 /* Note that the information in the `names' component of the global contour
 388    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 389
 390 struct binding_level
 391   {
 392     /* A chain of _DECL nodes for all variables, constants, functions,
 393        and typedef types.  These are in the reverse of the order
 394        supplied.  There may be OVERLOADs on this list, too, but they
 395        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 396     tree names;
 397
 398     /* A list of structure, union and enum definitions, for looking up
 399        tag names.
 400        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 401        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 402        or ENUMERAL_TYPE node.
 403
 404        C++: the TREE_VALUE nodes can be simple types for
 405        component_bindings.  */
 406     tree tags;
 407
 408     /* A list of USING_DECL nodes. */
 409     tree usings;
 410
 411     /* A list of used namespaces. PURPOSE is the namespace,
 412        VALUE the common ancestor with this binding_level's namespace. */
 413     tree using_directives;
 414
 415     /* If this binding level is the binding level for a class, then
 416        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 417        is the name of an entity bound in the class; the TREE_VALUE is
 418        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 419        when leaving class scope, we can restore the
 420        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 421        the DECL bound by this name in the class.  */
 422     tree class_shadowed;
 423
 424     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 425        is used for all binding levels.  */
 426     tree type_shadowed;
 427
 428     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 429        label in this scope.  The TREE_PURPOSE is the previous value of
 430        the IDENTIFIER_LABEL VALUE.  */
 431     tree shadowed_labels;
 432
 433     /* For each level (except not the global one),
 434        a chain of BLOCK nodes for all the levels
 435        that were entered and exited one level down.  */
 436     tree blocks;
 437
 438     /* The BLOCK node for this level, if one has been preallocated.
 439        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 440     tree this_block;
 441
 442     /* The _TYPE node for this level, if parm_flag == 2.  */
 443     tree this_class;
 444
 445     /* The binding level which this one is contained in (inherits from).  */
 446     struct binding_level *level_chain;
 447
 448     /* List of decls in `names' that have incomplete
 449        structure or union types.  */
 450     tree incomplete;
 451
 452     /* List of VAR_DECLS saved from a previous for statement.
 453        These would be dead in ISO-conforming code, but might
 454        be referenced in ARM-era code.  These are stored in a
 455        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 456     tree dead_vars_from_for;
 457
 458     /* 1 for the level that holds the parameters of a function.
 459        2 for the level that holds a class declaration.
 460        3 for levels that hold parameter declarations.  */
 461     unsigned parm_flag : 4;
 462
 463     /* 1 means make a BLOCK for this level regardless of all else.
 464        2 for temporary binding contours created by the compiler.  */
 465     unsigned keep : 3;
 466
 467     /* Nonzero if this level "doesn't exist" for tags.  */
 468     unsigned tag_transparent : 1;
 469
 470     /* Nonzero if this level can safely have additional
 471        cleanup-needing variables added to it.  */
 472     unsigned more_cleanups_ok : 1;
 473     unsigned have_cleanups : 1;
 474
 475     /* Nonzero if this level is for storing the decls for template
 476        parameters and generic decls; these decls will be discarded and
 477        replaced with a TEMPLATE_DECL.  */
 478     unsigned pseudo_global : 1;
 479
 480     /* This is set for a namespace binding level.  */
 481     unsigned namespace_p : 1;
 482
 483     /* True if this level is that of a for-statement where we need to
 484        worry about ambiguous (ARM or ISO) scope rules.  */
 485     unsigned is_for_scope : 1;
 486
 487     /* True if this level corresponds to an EH region, as for a try block.  */
 488     unsigned eh_region : 1;
 489
 490     /* One bit left for this word.  */
 491
 492 #if defined(DEBUG_CP_BINDING_LEVELS)
 493     /* Binding depth at which this level began.  */
 494     unsigned binding_depth;
 495 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 496   };
 497
 498 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 499
 500 /* The binding level currently in effect.  */
 501
 502 #define current_binding_level                   \
 503   (cfun                                         \
 504    ? cp_function_chain->bindings                \
 505    : scope_chain->bindings)
 506
 507 /* The binding level of the current class, if any.  */
 508
 509 #define class_binding_level scope_chain->class_bindings
 510
 511 /* A chain of binding_level structures awaiting reuse.  */
 512
 513 static struct binding_level *free_binding_level;
 514
 515 /* The outermost binding level, for names of file scope.
 516    This is created when the compiler is started and exists
 517    through the entire run.  */
 518
 519 static struct binding_level *global_binding_level;
 520
 521 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 522
 523 static int keep_next_level_flag;
 524
 525 #if defined(DEBUG_CP_BINDING_LEVELS)
 526 static int binding_depth = 0;
 527 static int is_class_level = 0;
 528
 529 static void
 530 indent ()
 531 {
 532   register unsigned i;
 533
 534   for (i = 0; i < binding_depth*2; i++)
 535     putc (' ', stderr);
 536 }
 537 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 538
 539 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 540
 541 static void
 542 push_binding_level (newlevel, tag_transparent, keep)
 543      struct binding_level *newlevel;
 544      int tag_transparent, keep;
 545 {
 546   /* Add this level to the front of the chain (stack) of levels that
 547      are active.  */
 548   bzero ((char*) newlevel, sizeof (struct binding_level));
 549   newlevel->level_chain = current_binding_level;
 550   current_binding_level = newlevel;
 551   newlevel->tag_transparent = tag_transparent;
 552   newlevel->more_cleanups_ok = 1;
 553
 554   /* We are called before expand_start_bindings, but after
 555      expand_eh_region_start for a try block; so we check this now,
 556      before the EH block is covered up.  */
 557   newlevel->eh_region = is_eh_region ();
 558
 559   newlevel->keep = keep;
 560 #if defined(DEBUG_CP_BINDING_LEVELS)
 561   newlevel->binding_depth = binding_depth;
 562   indent ();
 563   fprintf (stderr, "push %s level 0x%08x line %d\n",
 564            (is_class_level) ? "class" : "block", newlevel, lineno);
 565   is_class_level = 0;
 566   binding_depth++;
 567 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 568 }
 569
 570 /* Find the innermost enclosing class scope, and reset
 571    CLASS_BINDING_LEVEL appropriately.  */
 572
 573 static void
 574 find_class_binding_level ()
 575 {
 576   struct binding_level *level = current_binding_level;
 577
 578   while (level && level->parm_flag != 2)
 579     level = level->level_chain;
 580   if (level && level->parm_flag == 2)
 581     class_binding_level = level;
 582   else
 583     class_binding_level = 0;
 584 }
 585
 586 static void
 587 pop_binding_level ()
 588 {
 589   if (global_binding_level)
 590     {
 591       /* Cannot pop a level, if there are none left to pop.  */
 592       if (current_binding_level == global_binding_level)
 593         my_friendly_abort (123);
 594     }
 595   /* Pop the current level, and free the structure for reuse.  */
 596 #if defined(DEBUG_CP_BINDING_LEVELS)
 597   binding_depth--;
 598   indent ();
 599   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 600           (is_class_level) ? "class" : "block",
 601           current_binding_level, lineno);
 602   if (is_class_level != (current_binding_level == class_binding_level))
 603     {
 604       indent ();
 605       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 606     }
 607   is_class_level = 0;
 608 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 609   {
 610     register struct binding_level *level = current_binding_level;
 611     current_binding_level = current_binding_level->level_chain;
 612     level->level_chain = free_binding_level;
 613 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 614     if (level->binding_depth != binding_depth)
 615       abort ();
 616 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 617     free_binding_level = level;
 618     find_class_binding_level ();
 619   }
 620 }
 621
 622 static void
 623 suspend_binding_level ()
 624 {
 625   if (class_binding_level)
 626     current_binding_level = class_binding_level;
 627
 628   if (global_binding_level)
 629     {
 630       /* Cannot suspend a level, if there are none left to suspend.  */
 631       if (current_binding_level == global_binding_level)
 632         my_friendly_abort (123);
 633     }
 634   /* Suspend the current level.  */
 635 #if defined(DEBUG_CP_BINDING_LEVELS)
 636   binding_depth--;
 637   indent ();
 638   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 639           (is_class_level) ? "class" : "block",
 640           current_binding_level, lineno);
 641   if (is_class_level != (current_binding_level == class_binding_level))
 642     {
 643       indent ();
 644       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 645     }
 646   is_class_level = 0;
 647 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 648   current_binding_level = current_binding_level->level_chain;
 649   find_class_binding_level ();
 650 }
 651
 652 static void
 653 resume_binding_level (b)
 654      struct binding_level *b;
 655 {
 656   /* Resuming binding levels is meant only for namespaces,
 657      and those cannot nest into classes. */
 658   my_friendly_assert(!class_binding_level, 386);
 659   /* Also, resuming a non-directly nested namespace is a no-no.  */
 660   my_friendly_assert(b->level_chain == current_binding_level, 386);
 661   current_binding_level = b;
 662 #if defined(DEBUG_CP_BINDING_LEVELS)
 663   b->binding_depth = binding_depth;
 664   indent ();
 665   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 666            (is_class_level) ? "class" : "block", b, lineno);
 667   is_class_level = 0;
 668   binding_depth++;
 669 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 670 }
 671 \f
 672 /* Create a new `struct binding_level'.  */
 673
 674 static
 675 struct binding_level *
 676 make_binding_level ()
 677 {
 678   /* NOSTRICT */
 679   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 680 }
 681
 682 /* Nonzero if we are currently in the global binding level.  */
 683
 684 int
 685 global_bindings_p ()
 686 {
 687   return current_binding_level == global_binding_level;
 688 }
 689
 690 /* Return the innermost binding level that is not for a class scope.  */
 691
 692 static struct binding_level *
 693 innermost_nonclass_level ()
 694 {
 695   struct binding_level *b;
 696
 697   b = current_binding_level;
 698   while (b->parm_flag == 2)
 699     b = b->level_chain;
 700
 701   return b;
 702 }
 703
 704 /* Nonzero if we are currently in a toplevel binding level.  This
 705    means either the global binding level or a namespace in a toplevel
 706    binding level.  Since there are no non-toplevel namespace levels,
 707    this really means any namespace or pseudo-global level.  We also
 708    include a class whose context is toplevel.  */
 709
 710 int
 711 toplevel_bindings_p ()
 712 {
 713   struct binding_level *b = innermost_nonclass_level ();
 714
 715   return b->namespace_p || b->pseudo_global;
 716 }
 717
 718 /* Nonzero if this is a namespace scope, or if we are defining a class
 719    which is itself at namespace scope, or whose enclosing class is
 720    such a class, etc.  */
 721
 722 int
 723 namespace_bindings_p ()
 724 {
 725   struct binding_level *b = innermost_nonclass_level ();
 726
 727   return b->namespace_p;
 728 }
 729
 730 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 731    unconditionally.  Otherwise, use the normal logic to decide whether
 732    or not to create a BLOCK.  */
 733
 734 void
 735 keep_next_level (keep)
 736      int keep;
 737 {
 738   keep_next_level_flag = keep;
 739 }
 740
 741 /* Nonzero if the current level needs to have a BLOCK made.  */
 742
 743 int
 744 kept_level_p ()
 745 {
 746   return (current_binding_level->blocks != NULL_TREE
 747           || current_binding_level->keep
 748           || current_binding_level->names != NULL_TREE
 749           || (current_binding_level->tags != NULL_TREE
 750               && !current_binding_level->tag_transparent));
 751 }
 752
 753 void
 754 declare_pseudo_global_level ()
 755 {
 756   current_binding_level->pseudo_global = 1;
 757 }
 758
 759 static void
 760 declare_namespace_level ()
 761 {
 762   current_binding_level->namespace_p = 1;
 763 }
 764
 765 int
 766 pseudo_global_level_p ()
 767 {
 768   return current_binding_level->pseudo_global;
 769 }
 770
 771 void
 772 set_class_shadows (shadows)
 773      tree shadows;
 774 {
 775   class_binding_level->class_shadowed = shadows;
 776 }
 777
 778 /* Enter a new binding level.
 779    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 780    not for that of tags.  */
 781
 782 void
 783 pushlevel (tag_transparent)
 784      int tag_transparent;
 785 {
 786   struct binding_level *newlevel;
 787
 788   if (cfun && !doing_semantic_analysis_p ())
 789     return;
 790
 791   /* Reuse or create a struct for this binding level.  */
 792 #if defined(DEBUG_CP_BINDING_LEVELS)
 793   if (0)
 794 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 795   if (free_binding_level)
 796 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 797     {
 798       newlevel = free_binding_level;
 799       free_binding_level = free_binding_level->level_chain;
 800     }
 801   else
 802     newlevel = make_binding_level ();
 803
 804   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 805   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 806   keep_next_level_flag = 0;
 807 }
 808
 809 void
 810 note_level_for_for ()
 811 {
 812   current_binding_level->is_for_scope = 1;
 813 }
 814
 815 /* For a binding between a name and an entity at a block scope,
 816    this is the `struct binding_level' for the block.  */
 817 #define BINDING_LEVEL(NODE) \
 818    (((struct tree_binding*)NODE)->scope.level)
 819
 820 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 821    level at which this declaration is being bound.  */
 822
 823 static void
 824 push_binding (id, decl, level)
 825      tree id;
 826      tree decl;
 827      struct binding_level* level;
 828 {
 829   tree binding;
 830
 831   binding = make_node (CPLUS_BINDING);
 832
 833   /* Now, fill in the binding information.  */
 834   BINDING_VALUE (binding) = decl;
 835   BINDING_TYPE (binding) = NULL_TREE;
 836   BINDING_LEVEL (binding) = level;
 837   INHERITED_VALUE_BINDING_P (binding) = 0;
 838   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 839   BINDING_HAS_LEVEL_P (binding) = 1;
 840
 841   /* And put it on the front of the list of bindings for ID.  */
 842   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 843   IDENTIFIER_BINDING (id) = binding;
 844 }
 845
 846 /* ID is already bound in the current scope.  But, DECL is an
 847    additional binding for ID in the same scope.  This is the `struct
 848    stat' hack whereby a non-typedef class-name or enum-name can be
 849    bound at the same level as some other kind of entity.  It's the
 850    responsibility of the caller to check that inserting this name is
 851    legal here.  Returns nonzero if the new binding was successful.  */
 852 static int
 853 add_binding (id, decl)
 854      tree id;
 855      tree decl;
 856 {
 857   tree binding = IDENTIFIER_BINDING (id);
 858   int ok = 1;
 859
 860   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 861     /* The new name is the type name.  */
 862     BINDING_TYPE (binding) = decl;
 863   else if (!BINDING_VALUE (binding))
 864     /* This situation arises when push_class_level_binding moves an
 865        inherited type-binding out of the way to make room for a new
 866        value binding.  */
 867     BINDING_VALUE (binding) = decl;
 868   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 869            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 870     {
 871       /* The old binding was a type name.  It was placed in
 872          BINDING_VALUE because it was thought, at the point it was
 873          declared, to be the only entity with such a name.  Move the
 874          type name into the type slot; it is now hidden by the new
 875          binding.  */
 876       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 877       BINDING_VALUE (binding) = decl;
 878       INHERITED_VALUE_BINDING_P (binding) = 0;
 879     }
 880   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 881            && TREE_CODE (decl) == TYPE_DECL
 882            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 883            && same_type_p (TREE_TYPE (decl),
 884                            TREE_TYPE (BINDING_VALUE (binding))))
 885     /* We have two typedef-names, both naming the same type to have
 886        the same name.  This is OK because of:
 887
 888          [dcl.typedef]
 889
 890          In a given scope, a typedef specifier can be used to redefine
 891          the name of any type declared in that scope to refer to the
 892          type to which it already refers.  */
 893     ok = 0;
 894   else
 895     {
 896       cp_error ("declaration of `%#D'", decl);
 897       cp_error_at ("conflicts with previous declaration `%#D'",
 898                    BINDING_VALUE (binding));
 899       ok = 0;
 900     }
 901
 902   return ok;
 903 }
 904
 905 /* Add DECL to the list of things declared in B.  */
 906
 907 static void
 908 add_decl_to_level (decl, b)
 909      tree decl;
 910      struct binding_level *b;
 911 {
 912   /* We build up the list in reverse order, and reverse it later if
 913      necessary.  */
 914   TREE_CHAIN (decl) = b->names;
 915   b->names = decl;
 916 }
 917
 918 /* Bind DECL to ID in the current_binding_level, assumed to be a local
 919    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
 920    doesn't really belong to this binding level, that it got here
 921    through a using-declaration.  */
 922
 923 void
 924 push_local_binding (id, decl, flags)
 925      tree id;
 926      tree decl;
 927      int flags;
 928 {
 929   struct binding_level *b;
 930
 931   /* Skip over any local classes.  This makes sense if we call
 932      push_local_binding with a friend decl of a local class.  */
 933   b = current_binding_level;
 934   while (b->parm_flag == 2)
 935     b = b->level_chain;
 936
 937   if (lookup_name_current_level (id))
 938     {
 939       /* Supplement the existing binding.  */
 940       if (!add_binding (id, decl))
 941         /* It didn't work.  Something else must be bound at this
 942            level.  Do not add DECL to the list of things to pop
 943            later.  */
 944         return;
 945     }
 946   else
 947     /* Create a new binding.  */
 948     push_binding (id, decl, b);
 949
 950   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
 951     /* We must put the OVERLOAD into a TREE_LIST since the
 952        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
 953        decls that got here through a using-declaration.  */
 954     decl = build_tree_list (NULL_TREE, decl);
 955
 956   /* And put DECL on the list of things declared by the current
 957      binding level.  */
 958   add_decl_to_level (decl, b);
 959 }
 960
 961 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
 962    binding was successful.  */
 963
 964 int
 965 push_class_binding (id, decl)
 966      tree id;
 967      tree decl;
 968 {
 969   int result = 1;
 970   tree binding = IDENTIFIER_BINDING (id);
 971   tree context;
 972
 973   /* Note that we declared this value so that we can issue an error if
 974      this an illegal redeclaration of a name already used for some
 975      other purpose.  */
 976   note_name_declared_in_class (id, decl);
 977
 978   if (binding && BINDING_LEVEL (binding) == class_binding_level)
 979     /* Supplement the existing binding.  */
 980     result = add_binding (id, decl);
 981   else
 982     /* Create a new binding.  */
 983     push_binding (id, decl, class_binding_level);
 984
 985   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
 986      class-level declaration.  Note that we do not use DECL here
 987      because of the possibility of the `struct stat' hack; if DECL is
 988      a class-name or enum-name we might prefer a field-name, or some
 989      such.  */
 990   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
 991
 992   /* If this is a binding from a base class, mark it as such.  */
 993   binding = IDENTIFIER_BINDING (id);
 994   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
 995     {
 996       /* Any implicit typename must be from a base-class.  The
 997          context for an implicit typename declaration is always
 998          the derived class in which the lookup was done, so the checks
 999          based on the context of DECL below will not trigger.  */
1000       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1001         INHERITED_VALUE_BINDING_P (binding) = 1;
1002       else
1003         {
1004           if (TREE_CODE (decl) == OVERLOAD)
1005             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1006           else
1007             {
1008               my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd',
1009                                   0);
1010               context = CP_DECL_CONTEXT (decl);
1011             }
1012
1013           if (is_properly_derived_from (current_class_type, context))
1014             INHERITED_VALUE_BINDING_P (binding) = 1;
1015           else
1016             INHERITED_VALUE_BINDING_P (binding) = 0;
1017         }
1018     }
1019   else if (BINDING_VALUE (binding) == decl)
1020     /* We only encounter a TREE_LIST when push_class_decls detects an
1021        ambiguity.  Such an ambiguity can be overridden by a definition
1022        in this class.  */
1023     INHERITED_VALUE_BINDING_P (binding) = 1;
1024
1025   return result;
1026 }
1027
1028 /* Remove the binding for DECL which should be the innermost binding
1029    for ID.  */
1030
1031 static void
1032 pop_binding (id, decl)
1033      tree id;
1034      tree decl;
1035 {
1036   tree binding;
1037
1038   if (id == NULL_TREE)
1039     /* It's easiest to write the loops that call this function without
1040        checking whether or not the entities involved have names.  We
1041        get here for such an entity.  */
1042     return;
1043
1044   /* Get the innermost binding for ID.  */
1045   binding = IDENTIFIER_BINDING (id);
1046
1047   /* The name should be bound.  */
1048   my_friendly_assert (binding != NULL_TREE, 0);
1049
1050   /* The DECL will be either the ordinary binding or the type
1051      binding for this identifier.  Remove that binding.  */
1052   if (BINDING_VALUE (binding) == decl)
1053     BINDING_VALUE (binding) = NULL_TREE;
1054   else if (BINDING_TYPE (binding) == decl)
1055     BINDING_TYPE (binding) = NULL_TREE;
1056   else
1057     my_friendly_abort (0);
1058
1059   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1060     /* We're completely done with the innermost binding for this
1061        identifier.  Unhook it from the list of bindings.  */
1062     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1063 }
1064
1065 /* When a label goes out of scope, check to see if that label was used
1066    in a valid manner, and issue any appropriate warnings or errors.  */
1067
1068 static void
1069 pop_label (link)
1070      tree link;
1071 {
1072   tree label = TREE_VALUE (link);
1073
1074   if (!processing_template_decl && doing_semantic_analysis_p ())
1075     {
1076       if (DECL_INITIAL (label) == NULL_TREE)
1077         {
1078           cp_error_at ("label `%D' used but not defined", label);
1079           /* Avoid crashing later.  */
1080           define_label (input_filename, 1, DECL_NAME (label));
1081         }
1082       else if (warn_unused && !TREE_USED (label))
1083         cp_warning_at ("label `%D' defined but not used", label);
1084     }
1085
1086   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), TREE_PURPOSE (link));
1087 }
1088
1089 /* At the end of a function, all labels declared within the fucntion
1090    go out of scope.  BLOCK is the top-level block for the
1091    function.  */
1092
1093 static void
1094 pop_labels (block)
1095      tree block;
1096 {
1097   tree link;
1098
1099   /* Clear out the definitions of all label names, since their scopes
1100      end here.  */
1101   for (link = named_labels; link; link = TREE_CHAIN (link))
1102     {
1103       pop_label (link);
1104       /* Put the labels into the "variables" of the top-level block,
1105          so debugger can see them.  */
1106       TREE_CHAIN (TREE_VALUE (link)) = BLOCK_VARS (block);
1107       BLOCK_VARS (block) = TREE_VALUE (link);
1108     }
1109
1110   named_labels = NULL_TREE;
1111 }
1112
1113 /* Exit a binding level.
1114    Pop the level off, and restore the state of the identifier-decl mappings
1115    that were in effect when this level was entered.
1116
1117    If KEEP == 1, this level had explicit declarations, so
1118    and create a "block" (a BLOCK node) for the level
1119    to record its declarations and subblocks for symbol table output.
1120
1121    If FUNCTIONBODY is nonzero, this level is the body of a function,
1122    so create a block as if KEEP were set and also clear out all
1123    label names.
1124
1125    If REVERSE is nonzero, reverse the order of decls before putting
1126    them into the BLOCK.  */
1127
1128 tree
1129 poplevel (keep, reverse, functionbody)
1130      int keep;
1131      int reverse;
1132      int functionbody;
1133 {
1134   register tree link;
1135   /* The chain of decls was accumulated in reverse order.
1136      Put it into forward order, just for cleanliness.  */
1137   tree decls;
1138   int tmp = functionbody;
1139   int real_functionbody;
1140   tree tags;
1141   tree subblocks;
1142   tree block = NULL_TREE;
1143   tree decl;
1144   int block_previously_created;
1145   int leaving_for_scope;
1146
1147   if (cfun && !doing_semantic_analysis_p ())
1148     return NULL_TREE;
1149
1150   my_friendly_assert (current_binding_level->parm_flag != 2,
1151                       19990916);
1152
1153   real_functionbody = (current_binding_level->keep == 2
1154                        ? ((functionbody = 0), tmp) : functionbody);
1155   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1156   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1157
1158   my_friendly_assert (!current_binding_level->class_shadowed,
1159                       19990414);
1160
1161   /* We used to use KEEP == 2 to indicate that the new block should go
1162      at the beginning of the list of blocks at this binding level,
1163      rather than the end.  This hack is no longer used.  */
1164   my_friendly_assert (keep == 0 || keep == 1, 0);
1165
1166   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1167                       (HOST_WIDE_INT) current_binding_level->level_chain,
1168                       current_binding_level->parm_flag,
1169                       current_binding_level->keep);
1170
1171   if (current_binding_level->keep == 1)
1172     keep = 1;
1173
1174   /* Get the decls in the order they were written.
1175      Usually current_binding_level->names is in reverse order.
1176      But parameter decls were previously put in forward order.  */
1177
1178   if (reverse)
1179     current_binding_level->names
1180       = decls = nreverse (current_binding_level->names);
1181   else
1182     decls = current_binding_level->names;
1183
1184   /* Output any nested inline functions within this block
1185      if they weren't already output.  */
1186   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1187     if (TREE_CODE (decl) == FUNCTION_DECL
1188         && ! TREE_ASM_WRITTEN (decl)
1189         && DECL_INITIAL (decl) != NULL_TREE
1190         && TREE_ADDRESSABLE (decl)
1191         && decl_function_context (decl) == current_function_decl)
1192       {
1193         /* If this decl was copied from a file-scope decl
1194            on account of a block-scope extern decl,
1195            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1196         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1197           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1198         else
1199           {
1200             push_function_context ();
1201             output_inline_function (decl);
1202             pop_function_context ();
1203           }
1204       }
1205
1206   /* When not in function-at-a-time mode, expand_end_bindings will
1207      warn about unused variables.  But, in function-at-a-time mode
1208      expand_end_bindings is not passed the list of variables in the
1209      current scope, and therefore no warning is emitted.  So, we
1210      explicitly warn here.  */
1211   if (!processing_template_decl)
1212     warn_about_unused_variables (getdecls ());
1213
1214   /* If there were any declarations or structure tags in that level,
1215      or if this level is a function body,
1216      create a BLOCK to record them for the life of this function.  */
1217   block = NULL_TREE;
1218   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1219   if (block_previously_created)
1220     block = current_binding_level->this_block;
1221   else if (keep == 1 || functionbody)
1222     block = make_node (BLOCK);
1223   if (block != NULL_TREE)
1224     {
1225       if (block_previously_created)
1226         {
1227           if (decls || tags || subblocks)
1228             {
1229               if (BLOCK_VARS (block))
1230                 warning ("internal compiler error: debugging info corrupted");
1231
1232               BLOCK_VARS (block) = decls;
1233
1234               /* We can have previous subblocks and new subblocks when
1235                  doing fixup_gotos with complex cleanups.  We chain the new
1236                  subblocks onto the end of any pre-existing subblocks.  */
1237               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1238                                                  subblocks);
1239             }
1240         }
1241       else
1242         {
1243           BLOCK_VARS (block) = decls;
1244           BLOCK_SUBBLOCKS (block) = subblocks;
1245         }
1246     }
1247
1248   /* In each subblock, record that this is its superior.  */
1249   if (keep >= 0)
1250     for (link = subblocks; link; link = TREE_CHAIN (link))
1251       BLOCK_SUPERCONTEXT (link) = block;
1252
1253   /* We still support the old for-scope rules, whereby the variables
1254      in a for-init statement were in scope after the for-statement
1255      ended.  We only use the new rules in flag_new_for_scope is
1256      nonzero.  */
1257   leaving_for_scope
1258     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1259
1260   /* Remove declarations for all the DECLs in this level.  */
1261   for (link = decls; link; link = TREE_CHAIN (link))
1262     {
1263       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1264         {
1265           tree outer_binding
1266             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1267           tree ns_binding;
1268
1269           if (!outer_binding)
1270             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1271           else
1272             ns_binding = NULL_TREE;
1273
1274           if (outer_binding
1275               && (BINDING_LEVEL (outer_binding)
1276                   == current_binding_level->level_chain))
1277             /* We have something like:
1278
1279                  int i;
1280                  for (int i; ;);
1281
1282                and we are leaving the `for' scope.  There's no reason to
1283                keep the binding of the inner `i' in this case.  */
1284             pop_binding (DECL_NAME (link), link);
1285           else if ((outer_binding
1286                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1287                         == TYPE_DECL))
1288                    || (ns_binding
1289                        && TREE_CODE (ns_binding) == TYPE_DECL))
1290             /* Here, we have something like:
1291
1292                  typedef int I;
1293
1294                  void f () {
1295                    for (int I; ;);
1296                  }
1297
1298                We must pop the for-scope binding so we know what's a
1299                type and what isn't.  */
1300             pop_binding (DECL_NAME (link), link);
1301           else
1302             {
1303               /* Mark this VAR_DECL as dead so that we can tell we left it
1304                  there only for backward compatibility.  */
1305               DECL_DEAD_FOR_LOCAL (link) = 1;
1306
1307               /* Keep track of what should of have happenned when we
1308                  popped the binding.  */
1309               if (outer_binding && BINDING_VALUE (outer_binding))
1310                 DECL_SHADOWED_FOR_VAR (link)
1311                   = BINDING_VALUE (outer_binding);
1312
1313               /* Add it to the list of dead variables in the next
1314                  outermost binding to that we can remove these when we
1315                  leave that binding.  */
1316               current_binding_level->level_chain->dead_vars_from_for
1317                 = tree_cons (NULL_TREE, link,
1318                              current_binding_level->level_chain->
1319                              dead_vars_from_for);
1320
1321               /* Although we don't pop the CPLUS_BINDING, we do clear
1322                  its BINDING_LEVEL since the level is going away now.  */
1323               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1324                 = 0;
1325             }
1326         }
1327       else
1328         {
1329           /* Remove the binding.  */
1330           decl = link;
1331           if (TREE_CODE (decl) == TREE_LIST)
1332             decl = TREE_VALUE (decl);
1333           if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
1334             pop_binding (DECL_NAME (decl), decl);
1335           else if (TREE_CODE (decl) == OVERLOAD)
1336             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1337           else
1338             my_friendly_abort (0);
1339         }
1340     }
1341
1342   /* Remove declarations for any `for' variables from inner scopes
1343      that we kept around.  */
1344   for (link = current_binding_level->dead_vars_from_for;
1345        link; link = TREE_CHAIN (link))
1346     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1347
1348   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1349   for (link = current_binding_level->type_shadowed;
1350        link; link = TREE_CHAIN (link))
1351     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1352
1353   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1354   for (link = current_binding_level->shadowed_labels;
1355        link;
1356        link = TREE_CHAIN (link))
1357     pop_label (link);
1358
1359   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1360      list if a `using' declaration put them there.  The debugging
1361      back-ends won't understand OVERLOAD, so we remove them here.
1362      Because the BLOCK_VARS are (temporarily) shared with
1363      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1364      popped all the bindings.  */
1365   if (block)
1366     {
1367       tree* d;
1368
1369       for (d = &BLOCK_VARS (block); *d; )
1370         {
1371           if (TREE_CODE (*d) == TREE_LIST)
1372             *d = TREE_CHAIN (*d);
1373           else
1374             d = &TREE_CHAIN (*d);
1375         }
1376     }
1377
1378   /* If the level being exited is the top level of a function,
1379      check over all the labels.  */
1380   if (functionbody)
1381     {
1382       /* Since this is the top level block of a function, the vars are
1383          the function's parameters.  Don't leave them in the BLOCK
1384          because they are found in the FUNCTION_DECL instead.  */
1385       BLOCK_VARS (block) = 0;
1386       pop_labels (block);
1387     }
1388
1389   /* Any uses of undefined labels now operate under constraints
1390      of next binding contour.  */
1391   if (cfun)
1392     {
1393       struct binding_level *level_chain;
1394       level_chain = current_binding_level->level_chain;
1395       if (level_chain)
1396         {
1397           struct named_label_list *labels;
1398           for (labels = named_label_uses; labels; labels = labels->next)
1399             if (labels->binding_level == current_binding_level)
1400               {
1401                 labels->binding_level = level_chain;
1402                 labels->names_in_scope = level_chain->names;
1403               }
1404         }
1405     }
1406
1407   tmp = current_binding_level->keep;
1408
1409   pop_binding_level ();
1410   if (functionbody)
1411     DECL_INITIAL (current_function_decl) = block;
1412   else if (block)
1413     {
1414       if (!block_previously_created)
1415         current_binding_level->blocks
1416           = chainon (current_binding_level->blocks, block);
1417     }
1418   /* If we did not make a block for the level just exited,
1419      any blocks made for inner levels
1420      (since they cannot be recorded as subblocks in that level)
1421      must be carried forward so they will later become subblocks
1422      of something else.  */
1423   else if (subblocks)
1424     current_binding_level->blocks
1425       = chainon (current_binding_level->blocks, subblocks);
1426
1427   /* Each and every BLOCK node created here in `poplevel' is important
1428      (e.g. for proper debugging information) so if we created one
1429      earlier, mark it as "used".  */
1430   if (block)
1431     TREE_USED (block) = 1;
1432
1433   /* Take care of compiler's internal binding structures.  */
1434   if (tmp == 2)
1435     {
1436       tree scope_stmts;
1437
1438       scope_stmts
1439         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1440       if (block)
1441         {
1442           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1443           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1444         }
1445
1446       block = poplevel (keep, reverse, functionbody);
1447     }
1448
1449   return block;
1450 }
1451
1452 /* Delete the node BLOCK from the current binding level.
1453    This is used for the block inside a stmt expr ({...})
1454    so that the block can be reinserted where appropriate.  */
1455
1456 void
1457 delete_block (block)
1458      tree block;
1459 {
1460   tree t;
1461   if (current_binding_level->blocks == block)
1462     current_binding_level->blocks = TREE_CHAIN (block);
1463   for (t = current_binding_level->blocks; t;)
1464     {
1465       if (TREE_CHAIN (t) == block)
1466         TREE_CHAIN (t) = TREE_CHAIN (block);
1467       else
1468         t = TREE_CHAIN (t);
1469     }
1470   TREE_CHAIN (block) = NULL_TREE;
1471   /* Clear TREE_USED which is always set by poplevel.
1472      The flag is set again if insert_block is called.  */
1473   TREE_USED (block) = 0;
1474 }
1475
1476 /* Insert BLOCK at the end of the list of subblocks of the
1477    current binding level.  This is used when a BIND_EXPR is expanded,
1478    to handle the BLOCK node inside the BIND_EXPR.  */
1479
1480 void
1481 insert_block (block)
1482      tree block;
1483 {
1484   TREE_USED (block) = 1;
1485   current_binding_level->blocks
1486     = chainon (current_binding_level->blocks, block);
1487 }
1488
1489 /* Set the BLOCK node for the innermost scope
1490    (the one we are currently in).  */
1491
1492 void
1493 set_block (block)
1494     register tree block;
1495 {
1496   current_binding_level->this_block = block;
1497 }
1498
1499 /* Do a pushlevel for class declarations.  */
1500
1501 void
1502 pushlevel_class ()
1503 {
1504   register struct binding_level *newlevel;
1505
1506   /* Reuse or create a struct for this binding level.  */
1507 #if defined(DEBUG_CP_BINDING_LEVELS)
1508   if (0)
1509 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1510   if (free_binding_level)
1511 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1512     {
1513       newlevel = free_binding_level;
1514       free_binding_level = free_binding_level->level_chain;
1515     }
1516   else
1517     newlevel = make_binding_level ();
1518
1519 #if defined(DEBUG_CP_BINDING_LEVELS)
1520   is_class_level = 1;
1521 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1522
1523   push_binding_level (newlevel, 0, 0);
1524
1525   class_binding_level = current_binding_level;
1526   class_binding_level->parm_flag = 2;
1527   class_binding_level->this_class = current_class_type;
1528 }
1529
1530 /* ...and a poplevel for class declarations.  */
1531
1532 void
1533 poplevel_class ()
1534 {
1535   register struct binding_level *level = class_binding_level;
1536   tree shadowed;
1537
1538   my_friendly_assert (level != 0, 354);
1539
1540   /* If we're leaving a toplevel class, don't bother to do the setting
1541      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1542      shouldn't even be used when current_class_type isn't set, and second,
1543      if we don't touch it here, we're able to use the cache effect if the
1544      next time we're entering a class scope, it is the same class.  */
1545   if (current_class_depth != 1)
1546     {
1547       struct binding_level* b;
1548
1549       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1550       for (shadowed = level->class_shadowed;
1551            shadowed;
1552            shadowed = TREE_CHAIN (shadowed))
1553         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1554
1555       /* Find the next enclosing class, and recreate
1556          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1557       b = level->level_chain;
1558       while (b && b->parm_flag != 2)
1559         b = b->level_chain;
1560
1561       if (b)
1562         for (shadowed = b->class_shadowed;
1563              shadowed;
1564              shadowed = TREE_CHAIN (shadowed))
1565           {
1566             tree t;
1567
1568             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1569             while (t && BINDING_LEVEL (t) != b)
1570               t = TREE_CHAIN (t);
1571
1572             if (t)
1573               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1574                 = BINDING_VALUE (t);
1575           }
1576     }
1577   else
1578     /* Remember to save what IDENTIFIER's were bound in this scope so we
1579        can recover from cache misses.  */
1580     {
1581       previous_class_type = current_class_type;
1582       previous_class_values = class_binding_level->class_shadowed;
1583     }
1584   for (shadowed = level->type_shadowed;
1585        shadowed;
1586        shadowed = TREE_CHAIN (shadowed))
1587     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1588
1589   /* Remove the bindings for all of the class-level declarations.  */
1590   for (shadowed = level->class_shadowed;
1591        shadowed;
1592        shadowed = TREE_CHAIN (shadowed))
1593     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1594
1595   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1596                       (HOST_WIDE_INT) class_binding_level->level_chain,
1597                       class_binding_level->parm_flag,
1598                       class_binding_level->keep);
1599
1600   /* Now, pop out of the binding level which we created up in the
1601      `pushlevel_class' routine.  */
1602 #if defined(DEBUG_CP_BINDING_LEVELS)
1603   is_class_level = 1;
1604 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1605
1606   pop_binding_level ();
1607 }
1608
1609 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1610    for any names in enclosing classes.  */
1611
1612 void
1613 clear_identifier_class_values ()
1614 {
1615   tree t;
1616
1617   if (!class_binding_level)
1618     return;
1619
1620   for (t = class_binding_level->class_shadowed;
1621        t;
1622        t = TREE_CHAIN (t))
1623     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1624 }
1625
1626 /* Returns non-zero if T is a virtual function table.  */
1627
1628 int
1629 vtable_decl_p (t, data)
1630      tree t;
1631      void *data ATTRIBUTE_UNUSED;
1632 {
1633   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1634 }
1635
1636 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1637    functions.  */
1638
1639 int
1640 vtype_decl_p (t, data)
1641      tree t;
1642      void *data ATTRIBUTE_UNUSED;
1643 {
1644   return (TREE_CODE (t) == TYPE_DECL
1645           && TREE_TYPE (t) != error_mark_node
1646           && TYPE_LANG_SPECIFIC (TREE_TYPE (t))
1647           && CLASSTYPE_VSIZE (TREE_TYPE (t)));
1648 }
1649
1650 /* Return the declarations that are members of the namespace NS.  */
1651
1652 tree
1653 cp_namespace_decls (ns)
1654      tree ns;
1655 {
1656   return NAMESPACE_LEVEL (ns)->names;
1657 }
1658
1659 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1660    itself, calling F for each.  The DATA is passed to F as well.  */
1661
1662 static int
1663 walk_namespaces_r (namespace, f, data)
1664      tree namespace;
1665      walk_namespaces_fn f;
1666      void *data;
1667 {
1668   tree current;
1669   int result = 0;
1670
1671   result |= (*f) (namespace, data);
1672
1673   for (current = cp_namespace_decls (namespace);
1674        current;
1675        current = TREE_CHAIN (current))
1676     {
1677       if (TREE_CODE (current) != NAMESPACE_DECL
1678           || DECL_NAMESPACE_ALIAS (current))
1679         continue;
1680       if (!DECL_LANG_SPECIFIC (current))
1681         {
1682           /* Hmm. std. */
1683           my_friendly_assert (current == std_node, 393);
1684           continue;
1685         }
1686
1687       /* We found a namespace.  */
1688       result |= walk_namespaces_r (current, f, data);
1689     }
1690
1691   return result;
1692 }
1693
1694 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1695    F as well.  */
1696
1697 int
1698 walk_namespaces (f, data)
1699      walk_namespaces_fn f;
1700      void *data;
1701 {
1702   return walk_namespaces_r (global_namespace, f, data);
1703 }
1704
1705 struct walk_globals_data {
1706   walk_globals_pred p;
1707   walk_globals_fn f;
1708   void *data;
1709 };
1710
1711 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1712    for which P returns non-zero, call F with its address.  If any call
1713    to F returns a non-zero value, return a non-zero value.  */
1714
1715 static int
1716 walk_globals_r (namespace, data)
1717      tree namespace;
1718      void *data;
1719 {
1720   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1721   walk_globals_pred p = wgd->p;
1722   walk_globals_fn f = wgd->f;
1723   void *d = wgd->data;
1724   tree *t;
1725   int result = 0;
1726
1727   t = &NAMESPACE_LEVEL (namespace)->names;
1728
1729   while (*t)
1730     {
1731       tree glbl = *t;
1732
1733       if ((*p) (glbl, d))
1734         result |= (*f) (t, d);
1735
1736       /* If F changed *T, then *T still points at the next item to
1737          examine.  */
1738       if (*t == glbl)
1739         t = &TREE_CHAIN (*t);
1740     }
1741
1742   return result;
1743 }
1744
1745 /* Walk the global declarations.  Whenever one is found for which P
1746    returns non-zero, call F with its address.  If any call to F
1747    returns a non-zero value, return a non-zero value.  */
1748
1749 int
1750 walk_globals (p, f, data)
1751      walk_globals_pred p;
1752      walk_globals_fn f;
1753      void *data;
1754 {
1755   struct walk_globals_data wgd;
1756   wgd.p = p;
1757   wgd.f = f;
1758   wgd.data = data;
1759
1760   return walk_namespaces (walk_globals_r, &wgd);
1761 }
1762
1763 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1764    DATA is non-NULL, this is the last time we will call
1765    wrapup_global_declarations for this NAMESPACE.  */
1766
1767 int
1768 wrapup_globals_for_namespace (namespace, data)
1769      tree namespace;
1770      void *data;
1771 {
1772   tree globals = cp_namespace_decls (namespace);
1773   int len = list_length (globals);
1774   tree *vec = (tree *) alloca (sizeof (tree) * len);
1775   int i;
1776   int result;
1777   tree decl;
1778   int last_time = (data != 0);
1779
1780   if (last_time && namespace == global_namespace)
1781     /* Let compile_file handle the global namespace.  */
1782     return 0;
1783
1784   /* Process the decls in reverse order--earliest first.
1785      Put them into VEC from back to front, then take out from front.  */
1786
1787   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1788     {
1789       /* Pretend we've output an unused static variable.  This ensures
1790          that the toplevel __FUNCTION__ etc won't be emitted, unless
1791          needed. */
1792       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1793           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1794         {
1795           TREE_ASM_WRITTEN (decl) = 1;
1796           DECL_IGNORED_P (decl) = 1;
1797         }
1798       vec[len - i - 1] = decl;
1799     }
1800
1801   if (last_time)
1802     {
1803       check_global_declarations (vec, len);
1804       return 0;
1805     }
1806
1807   /* Temporarily mark vtables as external.  That prevents
1808      wrapup_global_declarations from writing them out; we must process
1809      them ourselves in finish_vtable_vardecl.  */
1810   for (i = 0; i < len; ++i)
1811     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1812       {
1813         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1814         DECL_EXTERNAL (vec[i]) = 1;
1815       }
1816
1817   /* Write out any globals that need to be output.  */
1818   result = wrapup_global_declarations (vec, len);
1819
1820   /* Undo the hack to DECL_EXTERNAL above.  */
1821   for (i = 0; i < len; ++i)
1822     if (vtable_decl_p (vec[i], /*data=*/0)
1823         && DECL_NOT_REALLY_EXTERN (vec[i]))
1824       {
1825         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1826         DECL_EXTERNAL (vec[i]) = 0;
1827       }
1828
1829   return result;
1830 }
1831
1832 \f
1833 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1834
1835 static void
1836 mark_binding_level (arg)
1837      void *arg;
1838 {
1839   struct binding_level *lvl = *(struct binding_level **)arg;
1840
1841   while (lvl)
1842     {
1843       ggc_mark_tree (lvl->names);
1844       ggc_mark_tree (lvl->tags);
1845       ggc_mark_tree (lvl->usings);
1846       ggc_mark_tree (lvl->using_directives);
1847       ggc_mark_tree (lvl->class_shadowed);
1848       ggc_mark_tree (lvl->type_shadowed);
1849       ggc_mark_tree (lvl->shadowed_labels);
1850       ggc_mark_tree (lvl->blocks);
1851       ggc_mark_tree (lvl->this_block);
1852       ggc_mark_tree (lvl->this_class);
1853       ggc_mark_tree (lvl->incomplete);
1854       ggc_mark_tree (lvl->dead_vars_from_for);
1855
1856       lvl = lvl->level_chain;
1857     }
1858 }
1859 \f
1860 /* For debugging.  */
1861 static int no_print_functions = 0;
1862 static int no_print_builtins = 0;
1863
1864 void
1865 print_binding_level (lvl)
1866      struct binding_level *lvl;
1867 {
1868   tree t;
1869   int i = 0, len;
1870   fprintf (stderr, " blocks=");
1871   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1872   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1873            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1874   if (lvl->tag_transparent)
1875     fprintf (stderr, " tag-transparent");
1876   if (lvl->more_cleanups_ok)
1877     fprintf (stderr, " more-cleanups-ok");
1878   if (lvl->have_cleanups)
1879     fprintf (stderr, " have-cleanups");
1880   fprintf (stderr, "\n");
1881   if (lvl->names)
1882     {
1883       fprintf (stderr, " names:\t");
1884       /* We can probably fit 3 names to a line?  */
1885       for (t = lvl->names; t; t = TREE_CHAIN (t))
1886         {
1887           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1888             continue;
1889           if (no_print_builtins
1890               && (TREE_CODE (t) == TYPE_DECL)
1891               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1892             continue;
1893
1894           /* Function decls tend to have longer names.  */
1895           if (TREE_CODE (t) == FUNCTION_DECL)
1896             len = 3;
1897           else
1898             len = 2;
1899           i += len;
1900           if (i > 6)
1901             {
1902               fprintf (stderr, "\n\t");
1903               i = len;
1904             }
1905           print_node_brief (stderr, "", t, 0);
1906           if (t == error_mark_node)
1907             break;
1908         }
1909       if (i)
1910         fprintf (stderr, "\n");
1911     }
1912   if (lvl->tags)
1913     {
1914       fprintf (stderr, " tags:\t");
1915       i = 0;
1916       for (t = lvl->tags; t; t = TREE_CHAIN (t))
1917         {
1918           if (TREE_PURPOSE (t) == NULL_TREE)
1919             len = 3;
1920           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1921             len = 2;
1922           else
1923             len = 4;
1924           i += len;
1925           if (i > 5)
1926             {
1927               fprintf (stderr, "\n\t");
1928               i = len;
1929             }
1930           if (TREE_PURPOSE (t) == NULL_TREE)
1931             {
1932               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1933               fprintf (stderr, ">");
1934             }
1935           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1936             print_node_brief (stderr, "", TREE_VALUE (t), 0);
1937           else
1938             {
1939               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1940               print_node_brief (stderr, "", TREE_VALUE (t), 0);
1941               fprintf (stderr, ">");
1942             }
1943         }
1944       if (i)
1945         fprintf (stderr, "\n");
1946     }
1947   if (lvl->class_shadowed)
1948     {
1949       fprintf (stderr, " class-shadowed:");
1950       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1951         {
1952           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1953         }
1954       fprintf (stderr, "\n");
1955     }
1956   if (lvl->type_shadowed)
1957     {
1958       fprintf (stderr, " type-shadowed:");
1959       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1960         {
1961           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1962         }
1963       fprintf (stderr, "\n");
1964     }
1965 }
1966
1967 void
1968 print_other_binding_stack (stack)
1969      struct binding_level *stack;
1970 {
1971   struct binding_level *level;
1972   for (level = stack; level != global_binding_level; level = level->level_chain)
1973     {
1974       fprintf (stderr, "binding level ");
1975       fprintf (stderr, HOST_PTR_PRINTF, level);
1976       fprintf (stderr, "\n");
1977       print_binding_level (level);
1978     }
1979 }
1980
1981 void
1982 print_binding_stack ()
1983 {
1984   struct binding_level *b;
1985   fprintf (stderr, "current_binding_level=");
1986   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1987   fprintf (stderr, "\nclass_binding_level=");
1988   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1989   fprintf (stderr, "\nglobal_binding_level=");
1990   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1991   fprintf (stderr, "\n");
1992   if (class_binding_level)
1993     {
1994       for (b = class_binding_level; b; b = b->level_chain)
1995         if (b == current_binding_level)
1996           break;
1997       if (b)
1998         b = class_binding_level;
1999       else
2000         b = current_binding_level;
2001     }
2002   else
2003     b = current_binding_level;
2004   print_other_binding_stack (b);
2005   fprintf (stderr, "global:\n");
2006   print_binding_level (global_binding_level);
2007 }
2008
2009 /* Namespace binding access routines: The namespace_bindings field of
2010    the identifier is polymorphic, with three possible values:
2011    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2012    indicating the BINDING_VALUE of global_namespace. */
2013
2014 /* Check whether the a binding for the name to scope is known.
2015    Assumes that the bindings of the name are already a list
2016    of bindings. Returns the binding found, or NULL_TREE. */
2017
2018 static tree
2019 find_binding (name, scope)
2020      tree name;
2021      tree scope;
2022 {
2023   tree iter, prev = NULL_TREE;
2024
2025   scope = ORIGINAL_NAMESPACE (scope);
2026
2027   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2028        iter = TREE_CHAIN (iter))
2029     {
2030       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2031       if (BINDING_SCOPE (iter) == scope)
2032         {
2033           /* Move binding found to the front of the list, so
2034              subsequent lookups will find it faster. */
2035           if (prev)
2036             {
2037               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2038               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2039               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2040             }
2041           return iter;
2042         }
2043       prev = iter;
2044     }
2045   return NULL_TREE;
2046 }
2047
2048 /* Always returns a binding for name in scope. If the
2049    namespace_bindings is not a list, convert it to one first.
2050    If no binding is found, make a new one. */
2051
2052 tree
2053 binding_for_name (name, scope)
2054      tree name;
2055      tree scope;
2056 {
2057   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2058   tree result;
2059
2060   scope = ORIGINAL_NAMESPACE (scope);
2061
2062   if (b && TREE_CODE (b) != CPLUS_BINDING)
2063     {
2064       /* Get rid of optimization for global scope. */
2065       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2066       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2067       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2068     }
2069   if (b && (result = find_binding (name, scope)))
2070     return result;
2071   /* Not found, make a new one. */
2072   result = make_node (CPLUS_BINDING);
2073   TREE_CHAIN (result) = b;
2074   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2075   BINDING_SCOPE (result) = scope;
2076   BINDING_TYPE (result) = NULL_TREE;
2077   BINDING_VALUE (result) = NULL_TREE;
2078   return result;
2079 }
2080
2081 /* Return the binding value for name in scope, considering that
2082    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2083
2084 tree
2085 namespace_binding (name, scope)
2086      tree name;
2087      tree scope;
2088 {
2089   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2090   if (b == NULL_TREE)
2091     return NULL_TREE;
2092   if (scope == NULL_TREE)
2093     scope = global_namespace;
2094   if (TREE_CODE (b) != CPLUS_BINDING)
2095     return (scope == global_namespace) ? b : NULL_TREE;
2096   name = find_binding (name,scope);
2097   if (name == NULL_TREE)
2098     return name;
2099   return BINDING_VALUE (name);
2100 }
2101
2102 /* Set the binding value for name in scope. If modifying the binding
2103    of global_namespace is attempted, try to optimize it. */
2104
2105 void
2106 set_namespace_binding (name, scope, val)
2107      tree name;
2108      tree scope;
2109      tree val;
2110 {
2111   tree b;
2112
2113   if (scope == NULL_TREE)
2114     scope = global_namespace;
2115
2116   if (scope == global_namespace)
2117     {
2118       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2119       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2120         {
2121           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2122           return;
2123         }
2124     }
2125   b = binding_for_name (name, scope);
2126   BINDING_VALUE (b) = val;
2127 }
2128
2129 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2130    select a name that is unique to this compilation unit.  */
2131
2132 void
2133 push_namespace (name)
2134      tree name;
2135 {
2136   tree d = NULL_TREE;
2137   int need_new = 1;
2138   int implicit_use = 0;
2139   int global = 0;
2140   if (!global_namespace)
2141     {
2142       /* This must be ::. */
2143       my_friendly_assert (name == get_identifier ("::"), 377);
2144       global = 1;
2145     }
2146   else if (!name)
2147     {
2148       /* The name of anonymous namespace is unique for the translation
2149          unit.  */
2150       if (!anonymous_namespace_name)
2151         anonymous_namespace_name = get_file_function_name ('N');
2152       name = anonymous_namespace_name;
2153       d = IDENTIFIER_NAMESPACE_VALUE (name);
2154       if (d)
2155         /* Reopening anonymous namespace.  */
2156         need_new = 0;
2157       implicit_use = 1;
2158     }
2159   else if (current_namespace == global_namespace
2160            && name == DECL_NAME (std_node))
2161     {
2162       in_std++;
2163       return;
2164     }
2165   else
2166     {
2167       /* Check whether this is an extended namespace definition. */
2168       d = IDENTIFIER_NAMESPACE_VALUE (name);
2169       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2170         {
2171           need_new = 0;
2172           if (DECL_NAMESPACE_ALIAS (d))
2173             {
2174               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2175                         d, DECL_NAMESPACE_ALIAS (d));
2176               d = DECL_NAMESPACE_ALIAS (d);
2177             }
2178         }
2179     }
2180
2181   if (need_new)
2182     {
2183       /* Make a new namespace, binding the name to it. */
2184       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2185       /* The global namespace is not pushed, and the global binding
2186          level is set elsewhere.  */
2187       if (!global)
2188         {
2189           d = pushdecl (d);
2190           pushlevel (0);
2191           declare_namespace_level ();
2192           NAMESPACE_LEVEL (d) = current_binding_level;
2193         }
2194     }
2195   else
2196     resume_binding_level (NAMESPACE_LEVEL (d));
2197
2198   if (implicit_use)
2199     do_using_directive (d);
2200   /* Enter the name space. */
2201   current_namespace = d;
2202 }
2203
2204 /* Pop from the scope of the current namespace.  */
2205
2206 void
2207 pop_namespace ()
2208 {
2209   if (current_namespace == global_namespace)
2210     {
2211       my_friendly_assert (in_std>0, 980421);
2212       in_std--;
2213       return;
2214     }
2215   current_namespace = CP_DECL_CONTEXT (current_namespace);
2216   /* The binding level is not popped, as it might be re-opened later.  */
2217   suspend_binding_level ();
2218 }
2219
2220 /* Push into the scope of the namespace NS, even if it is deeply
2221    nested within another namespace.  */
2222
2223 void
2224 push_nested_namespace (ns)
2225      tree ns;
2226 {
2227   if (ns == global_namespace)
2228     push_to_top_level ();
2229   else
2230     {
2231       push_nested_namespace (CP_DECL_CONTEXT (ns));
2232       push_namespace (DECL_NAME (ns));
2233     }
2234 }
2235
2236 /* Pop back from the scope of the namespace NS, which was previously
2237    entered with push_nested_namespace.  */
2238
2239 void
2240 pop_nested_namespace (ns)
2241      tree ns;
2242 {
2243   while (ns != global_namespace)
2244     {
2245       pop_namespace ();
2246       ns = CP_DECL_CONTEXT (ns);
2247     }
2248
2249   pop_from_top_level ();
2250 }
2251
2252 \f
2253 /* Subroutines for reverting temporarily to top-level for instantiation
2254    of templates and such.  We actually need to clear out the class- and
2255    local-value slots of all identifiers, so that only the global values
2256    are at all visible.  Simply setting current_binding_level to the global
2257    scope isn't enough, because more binding levels may be pushed.  */
2258 struct saved_scope *scope_chain;
2259
2260 /* Mark ST for GC.  */
2261
2262 static void
2263 mark_stmt_tree (st)
2264      struct stmt_tree *st;
2265 {
2266   ggc_mark_tree (st->x_last_stmt);
2267   ggc_mark_tree (st->x_last_expr_type);
2268 }
2269
2270 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2271
2272 static void
2273 mark_saved_scope (arg)
2274      void *arg;
2275 {
2276   struct saved_scope *t = *(struct saved_scope **)arg;
2277   while (t)
2278     {
2279       mark_binding_level (&t->class_bindings);
2280       ggc_mark_tree (t->old_bindings);
2281       ggc_mark_tree (t->old_namespace);
2282       ggc_mark_tree (t->class_name);
2283       ggc_mark_tree (t->class_type);
2284       ggc_mark_tree (t->access_specifier);
2285       ggc_mark_tree (t->function_decl);
2286       if (t->lang_base)
2287         ggc_mark_tree_varray (t->lang_base);
2288       ggc_mark_tree (t->lang_name);
2289       ggc_mark_tree (t->x_function_parms);
2290       ggc_mark_tree (t->template_parms);
2291       ggc_mark_tree (t->x_previous_class_type);
2292       ggc_mark_tree (t->x_previous_class_values);
2293       ggc_mark_tree (t->x_saved_tree);
2294       ggc_mark_tree (t->incomplete);
2295       ggc_mark_tree (t->lookups);
2296
2297       mark_stmt_tree (&t->x_stmt_tree);
2298       mark_binding_level (&t->bindings);
2299       t = t->prev;
2300     }
2301 }
2302
2303 static tree
2304 store_bindings (names, old_bindings)
2305      tree names, old_bindings;
2306 {
2307   tree t;
2308   for (t = names; t; t = TREE_CHAIN (t))
2309     {
2310       tree binding, t1, id;
2311
2312       if (TREE_CODE (t) == TREE_LIST)
2313         id = TREE_PURPOSE (t);
2314       else
2315         id = DECL_NAME (t);
2316
2317       if (!id
2318           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2319              we have no IDENTIFIER_BINDING if we have left the class
2320              scope, but cached the class-level declarations.  */
2321           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2322         continue;
2323
2324       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2325         if (TREE_VEC_ELT (t1, 0) == id)
2326           goto skip_it;
2327
2328       binding = make_tree_vec (4);
2329
2330       if (id)
2331         {
2332           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2333           TREE_VEC_ELT (binding, 0) = id;
2334           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2335           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2336           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2337           IDENTIFIER_BINDING (id) = NULL_TREE;
2338           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2339         }
2340       TREE_CHAIN (binding) = old_bindings;
2341       old_bindings = binding;
2342     skip_it:
2343       ;
2344     }
2345   return old_bindings;
2346 }
2347
2348 void
2349 maybe_push_to_top_level (pseudo)
2350      int pseudo;
2351 {
2352   struct saved_scope *s;
2353   struct binding_level *b;
2354   tree old_bindings;
2355   int need_pop;
2356
2357   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2358
2359   b = scope_chain ? current_binding_level : 0;
2360
2361   /* If we're in the middle of some function, save our state.  */
2362   if (cfun)
2363     {
2364       need_pop = 1;
2365       push_function_context_to (NULL_TREE);
2366     }
2367   else
2368     need_pop = 0;
2369
2370   old_bindings = NULL_TREE;
2371   if (scope_chain && previous_class_type)
2372     old_bindings = store_bindings (previous_class_values, old_bindings);
2373
2374   /* Have to include global_binding_level, because class-level decls
2375      aren't listed anywhere useful.  */
2376   for (; b; b = b->level_chain)
2377     {
2378       tree t;
2379
2380       /* Template IDs are inserted into the global level. If they were
2381          inserted into namespace level, finish_file wouldn't find them
2382          when doing pending instantiations. Therefore, don't stop at
2383          namespace level, but continue until :: .  */
2384       if (b == global_binding_level || (pseudo && b->pseudo_global))
2385         break;
2386
2387       old_bindings = store_bindings (b->names, old_bindings);
2388       /* We also need to check class_shadowed to save class-level type
2389          bindings, since pushclass doesn't fill in b->names.  */
2390       if (b->parm_flag == 2)
2391         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2392
2393       /* Unwind type-value slots back to top level.  */
2394       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2395         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2396     }
2397   s->prev = scope_chain;
2398   s->old_bindings = old_bindings;
2399   s->bindings = b;
2400   s->need_pop_function_context = need_pop;
2401   s->function_decl = current_function_decl;
2402
2403   scope_chain = s;
2404   current_function_decl = NULL_TREE;
2405   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2406   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2407   current_lang_name = lang_name_cplusplus;
2408   strict_prototype = strict_prototypes_lang_cplusplus;
2409   current_namespace = global_namespace;
2410 }
2411
2412 void
2413 push_to_top_level ()
2414 {
2415   maybe_push_to_top_level (0);
2416 }
2417
2418 void
2419 pop_from_top_level ()
2420 {
2421   struct saved_scope *s = scope_chain;
2422   tree t;
2423
2424   /* Clear out class-level bindings cache.  */
2425   if (previous_class_type)
2426     invalidate_class_lookup_cache ();
2427
2428   VARRAY_FREE (current_lang_base);
2429
2430   scope_chain = s->prev;
2431   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2432     {
2433       tree id = TREE_VEC_ELT (t, 0);
2434       if (id)
2435         {
2436           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2437           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2438           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2439         }
2440     }
2441
2442   if (current_lang_name == lang_name_cplusplus)
2443     strict_prototype = strict_prototypes_lang_cplusplus;
2444   else if (current_lang_name == lang_name_c)
2445     strict_prototype = strict_prototypes_lang_c;
2446
2447   /* If we were in the middle of compiling a function, restore our
2448      state.  */
2449   if (s->need_pop_function_context)
2450     pop_function_context_from (NULL_TREE);
2451   current_function_decl = s->function_decl;
2452
2453   free (s);
2454 }
2455 \f
2456 /* Push a definition of struct, union or enum tag "name".
2457    into binding_level "b".   "type" should be the type node,
2458    We assume that the tag "name" is not already defined.
2459
2460    Note that the definition may really be just a forward reference.
2461    In that case, the TYPE_SIZE will be a NULL_TREE.
2462
2463    C++ gratuitously puts all these tags in the name space.  */
2464
2465 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2466    record the shadowed value for this binding contour.  TYPE is
2467    the type that ID maps to.  */
2468
2469 static void
2470 set_identifier_type_value_with_scope (id, type, b)
2471      tree id;
2472      tree type;
2473      struct binding_level *b;
2474 {
2475   if (!b->namespace_p)
2476     {
2477       /* Shadow the marker, not the real thing, so that the marker
2478          gets restored later. */
2479       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2480       b->type_shadowed
2481         = tree_cons (id, old_type_value, b->type_shadowed);
2482     }
2483   else
2484     {
2485       tree binding = binding_for_name (id, current_namespace);
2486       BINDING_TYPE (binding) = type;
2487       /* Store marker instead of real type. */
2488       type = global_type_node;
2489     }
2490   SET_IDENTIFIER_TYPE_VALUE (id, type);
2491 }
2492
2493 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2494
2495 void
2496 set_identifier_type_value (id, type)
2497      tree id;
2498      tree type;
2499 {
2500   set_identifier_type_value_with_scope (id, type, current_binding_level);
2501 }
2502
2503 /* Return the type associated with id. */
2504
2505 tree
2506 identifier_type_value (id)
2507      tree id;
2508 {
2509   /* There is no type with that name, anywhere. */
2510   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2511     return NULL_TREE;
2512   /* This is not the type marker, but the real thing. */
2513   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2514     return REAL_IDENTIFIER_TYPE_VALUE (id);
2515   /* Have to search for it. It must be on the global level, now.
2516      Ask lookup_name not to return non-types. */
2517   id = lookup_name_real (id, 2, 1, 0);
2518   if (id)
2519     return TREE_TYPE (id);
2520   return NULL_TREE;
2521 }
2522
2523 /* Pop off extraneous binding levels left over due to syntax errors.
2524
2525    We don't pop past namespaces, as they might be valid.  */
2526
2527 void
2528 pop_everything ()
2529 {
2530 #ifdef DEBUG_CP_BINDING_LEVELS
2531   fprintf (stderr, "XXX entering pop_everything ()\n");
2532 #endif
2533   while (!toplevel_bindings_p ())
2534     {
2535       if (current_binding_level->parm_flag == 2)
2536         pop_nested_class ();
2537       else
2538         poplevel (0, 0, 0);
2539     }
2540 #ifdef DEBUG_CP_BINDING_LEVELS
2541   fprintf (stderr, "XXX leaving pop_everything ()\n");
2542 #endif
2543 }
2544
2545 /* The type TYPE is being declared.  If it is a class template, or a
2546    specialization of a class template, do any processing required and
2547    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2548    being declared a friend.  B is the binding level at which this TYPE
2549    should be bound.
2550
2551    Returns the TYPE_DECL for TYPE, which may have been altered by this
2552    processing.  */
2553
2554 static tree
2555 maybe_process_template_type_declaration (type, globalize, b)
2556      tree type;
2557      int globalize;
2558      struct binding_level* b;
2559 {
2560   tree decl = TYPE_NAME (type);
2561
2562   if (processing_template_parmlist)
2563     /* You can't declare a new template type in a template parameter
2564        list.  But, you can declare a non-template type:
2565
2566          template <class A*> struct S;
2567
2568        is a forward-declaration of `A'.  */
2569     ;
2570   else
2571     {
2572       maybe_check_template_type (type);
2573
2574       my_friendly_assert (IS_AGGR_TYPE (type)
2575                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2576
2577
2578       if (processing_template_decl)
2579         {
2580           /* This may change after the call to
2581              push_template_decl_real, but we want the original value.  */
2582           tree name = DECL_NAME (decl);
2583
2584           decl = push_template_decl_real (decl, globalize);
2585           /* If the current binding level is the binding level for the
2586              template parameters (see the comment in
2587              begin_template_parm_list) and the enclosing level is a class
2588              scope, and we're not looking at a friend, push the
2589              declaration of the member class into the class scope.  In the
2590              friend case, push_template_decl will already have put the
2591              friend into global scope, if appropriate.  */
2592           if (TREE_CODE (type) != ENUMERAL_TYPE
2593               && !globalize && b->pseudo_global
2594               && b->level_chain->parm_flag == 2)
2595             {
2596               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2597               /* Put this tag on the list of tags for the class, since
2598                  that won't happen below because B is not the class
2599                  binding level, but is instead the pseudo-global level.  */
2600               b->level_chain->tags =
2601                 tree_cons (name, type, b->level_chain->tags);
2602               if (TYPE_SIZE (current_class_type) == NULL_TREE)
2603                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2604             }
2605         }
2606     }
2607
2608   return decl;
2609 }
2610
2611 /* In C++, you don't have to write `struct S' to refer to `S'; you
2612    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2613    if the user had written `typedef struct S S'.  Create and return
2614    the TYPE_DECL for TYPE.  */
2615
2616 tree
2617 create_implicit_typedef (name, type)
2618      tree name;
2619      tree type;
2620 {
2621   tree decl;
2622
2623   decl = build_decl (TYPE_DECL, name, type);
2624   SET_DECL_ARTIFICIAL (decl);
2625   /* There are other implicit type declarations, like the one *within*
2626      a class that allows you to write `S::S'.  We must distinguish
2627      amongst these.  */
2628   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2629   TYPE_NAME (type) = decl;
2630
2631   return decl;
2632 }
2633
2634 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2635    Normally put it into the inner-most non-tag-transparent scope,
2636    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2637    The latter is needed for implicit declarations.  */
2638
2639 void
2640 pushtag (name, type, globalize)
2641      tree name, type;
2642      int globalize;
2643 {
2644   register struct binding_level *b;
2645
2646   b = current_binding_level;
2647   while (b->tag_transparent
2648          || (globalize && b->parm_flag == 2))
2649     b = b->level_chain;
2650
2651   b->tags = tree_cons (name, type, b->tags);
2652
2653   if (name)
2654     {
2655       /* Do C++ gratuitous typedefing.  */
2656       if (IDENTIFIER_TYPE_VALUE (name) != type)
2657         {
2658           register tree d = NULL_TREE;
2659           int in_class = 0;
2660           tree context = TYPE_CONTEXT (type);
2661
2662           if (! context)
2663             {
2664               tree cs = current_scope ();
2665
2666               if (! globalize)
2667                 context = cs;
2668               else if (cs != NULL_TREE
2669                        && TREE_CODE_CLASS (TREE_CODE (cs)) == 't')
2670                 /* When declaring a friend class of a local class, we want
2671                    to inject the newly named class into the scope
2672                    containing the local class, not the namespace scope.  */
2673                 context = decl_function_context (get_type_decl (cs));
2674             }
2675           if (!context)
2676             context = current_namespace;
2677
2678           if ((b->pseudo_global && b->level_chain->parm_flag == 2)
2679               || b->parm_flag == 2)
2680             in_class = 1;
2681
2682           if (current_lang_name == lang_name_java)
2683             TYPE_FOR_JAVA (type) = 1;
2684
2685           d = create_implicit_typedef (name, type);
2686           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2687           if (! in_class)
2688             set_identifier_type_value_with_scope (name, type, b);
2689
2690           d = maybe_process_template_type_declaration (type,
2691                                                        globalize, b);
2692
2693           if (b->parm_flag == 2)
2694             {
2695               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2696                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2697                    class.  But if it's a member template class, we
2698                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2699                    is done later.  */
2700                 finish_member_declaration (d);
2701               else
2702                 pushdecl_class_level (d);
2703             }
2704           else
2705             d = pushdecl_with_scope (d, b);
2706
2707           if (ANON_AGGRNAME_P (name))
2708             DECL_IGNORED_P (d) = 1;
2709
2710           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2711           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2712           if (!uses_template_parms (type))
2713             DECL_ASSEMBLER_NAME (d)
2714               = get_identifier (build_overload_name (type, 1, 1));
2715         }
2716       if (b->parm_flag == 2)
2717         {
2718           if (TYPE_SIZE (current_class_type) == NULL_TREE)
2719             CLASSTYPE_TAGS (current_class_type) = b->tags;
2720         }
2721     }
2722
2723   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2724     /* Use the canonical TYPE_DECL for this node.  */
2725     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2726   else
2727     {
2728       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2729          will be the tagged type we just added to the current
2730          binding level.  This fake NULL-named TYPE_DECL node helps
2731          dwarfout.c to know when it needs to output a
2732          representation of a tagged type, and it also gives us a
2733          convenient place to record the "scope start" address for
2734          the tagged type.  */
2735
2736       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2737       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2738     }
2739 }
2740
2741 /* Counter used to create anonymous type names.  */
2742
2743 static int anon_cnt = 0;
2744
2745 /* Return an IDENTIFIER which can be used as a name for
2746    anonymous structs and unions.  */
2747
2748 tree
2749 make_anon_name ()
2750 {
2751   char buf[32];
2752
2753   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2754   return get_identifier (buf);
2755 }
2756
2757 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2758    This keeps dbxout from getting confused.  */
2759
2760 void
2761 clear_anon_tags ()
2762 {
2763   register struct binding_level *b;
2764   register tree tags;
2765   static int last_cnt = 0;
2766
2767   /* Fast out if no new anon names were declared.  */
2768   if (last_cnt == anon_cnt)
2769     return;
2770
2771   b = current_binding_level;
2772   while (b->tag_transparent)
2773     b = b->level_chain;
2774   tags = b->tags;
2775   while (tags)
2776     {
2777       /* A NULL purpose means we have already processed all tags
2778          from here to the end of the list.  */
2779       if (TREE_PURPOSE (tags) == NULL_TREE)
2780         break;
2781       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2782         TREE_PURPOSE (tags) = NULL_TREE;
2783       tags = TREE_CHAIN (tags);
2784     }
2785   last_cnt = anon_cnt;
2786 }
2787 \f
2788 /* Subroutine of duplicate_decls: return truthvalue of whether
2789    or not types of these decls match.
2790
2791    For C++, we must compare the parameter list so that `int' can match
2792    `int&' in a parameter position, but `int&' is not confused with
2793    `const int&'.  */
2794
2795 int
2796 decls_match (newdecl, olddecl)
2797      tree newdecl, olddecl;
2798 {
2799   int types_match;
2800
2801   if (newdecl == olddecl)
2802     return 1;
2803
2804   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2805     /* If the two DECLs are not even the same kind of thing, we're not
2806        interested in their types.  */
2807     return 0;
2808
2809   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2810     {
2811       tree f1 = TREE_TYPE (newdecl);
2812       tree f2 = TREE_TYPE (olddecl);
2813       tree p1 = TYPE_ARG_TYPES (f1);
2814       tree p2 = TYPE_ARG_TYPES (f2);
2815
2816       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2817           && ! (DECL_LANGUAGE (newdecl) == lang_c
2818                 && DECL_LANGUAGE (olddecl) == lang_c))
2819         return 0;
2820
2821       if (TREE_CODE (f1) != TREE_CODE (f2))
2822         return 0;
2823
2824       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2825         {
2826           if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2827               && p2 == NULL_TREE)
2828             {
2829               types_match = self_promoting_args_p (p1);
2830               if (p1 == void_list_node)
2831                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2832             }
2833           else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2834                    && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2835             {
2836               types_match = self_promoting_args_p (p2);
2837               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2838             }
2839           else
2840             types_match = compparms (p1, p2);
2841         }
2842       else
2843         types_match = 0;
2844     }
2845   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2846     {
2847       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2848                                 DECL_TEMPLATE_PARMS (olddecl)))
2849         return 0;
2850
2851       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2852         types_match = 1;
2853       else
2854         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2855                                    DECL_TEMPLATE_RESULT (newdecl));
2856     }
2857   else
2858     {
2859       if (TREE_TYPE (newdecl) == error_mark_node)
2860         types_match = TREE_TYPE (olddecl) == error_mark_node;
2861       else if (TREE_TYPE (olddecl) == NULL_TREE)
2862         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2863       else if (TREE_TYPE (newdecl) == NULL_TREE)
2864         types_match = 0;
2865       else
2866         types_match = comptypes (TREE_TYPE (newdecl),
2867                                  TREE_TYPE (olddecl),
2868                                  COMPARE_REDECLARATION);
2869     }
2870
2871   return types_match;
2872 }
2873
2874 /* If NEWDECL is `static' and an `extern' was seen previously,
2875    warn about it.  OLDDECL is the previous declaration.
2876
2877    Note that this does not apply to the C++ case of declaring
2878    a variable `extern const' and then later `const'.
2879
2880    Don't complain about built-in functions, since they are beyond
2881    the user's control.  */
2882
2883 static void
2884 warn_extern_redeclared_static (newdecl, olddecl)
2885      tree newdecl, olddecl;
2886 {
2887   static const char *explicit_extern_static_warning
2888     = "`%D' was declared `extern' and later `static'";
2889   static const char *implicit_extern_static_warning
2890     = "`%D' was declared implicitly `extern' and later `static'";
2891
2892   tree name;
2893
2894   if (TREE_CODE (newdecl) == TYPE_DECL
2895       || TREE_CODE (newdecl) == TEMPLATE_DECL)
2896     return;
2897
2898   /* Don't get confused by static member functions; that's a different
2899      use of `static'.  */
2900   if (TREE_CODE (newdecl) == FUNCTION_DECL
2901       && DECL_STATIC_FUNCTION_P (newdecl))
2902     return;
2903
2904   /* If the old declaration was `static', or the new one isn't, then
2905      then everything is OK.  */
2906   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2907     return;
2908
2909   /* It's OK to declare a builtin function as `static'.  */
2910   if (TREE_CODE (olddecl) == FUNCTION_DECL
2911       && DECL_ARTIFICIAL (olddecl))
2912     return;
2913
2914   name = DECL_ASSEMBLER_NAME (newdecl);
2915   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2916               ? implicit_extern_static_warning
2917               : explicit_extern_static_warning, newdecl);
2918   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2919 }
2920
2921 /* Handle when a new declaration NEWDECL has the same name as an old
2922    one OLDDECL in the same binding contour.  Prints an error message
2923    if appropriate.
2924
2925    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2926    Otherwise, return 0.  */
2927
2928 int
2929 duplicate_decls (newdecl, olddecl)
2930      tree newdecl, olddecl;
2931 {
2932   unsigned olddecl_uid = DECL_UID (olddecl);
2933   int olddecl_friend = 0, types_match = 0;
2934   int new_defines_function = 0;
2935
2936   if (newdecl == olddecl)
2937     return 1;
2938
2939   types_match = decls_match (newdecl, olddecl);
2940
2941   /* If either the type of the new decl or the type of the old decl is an
2942      error_mark_node, then that implies that we have already issued an
2943      error (earlier) for some bogus type specification, and in that case,
2944      it is rather pointless to harass the user with yet more error message
2945      about the same declaration, so just pretend the types match here.  */
2946   if (TREE_TYPE (newdecl) == error_mark_node
2947       || TREE_TYPE (olddecl) == error_mark_node)
2948     types_match = 1;
2949
2950   /* Check for redeclaration and other discrepancies. */
2951   if (TREE_CODE (olddecl) == FUNCTION_DECL
2952       && DECL_ARTIFICIAL (olddecl))
2953     {
2954       if (TREE_CODE (newdecl) != FUNCTION_DECL)
2955         {
2956           /* If you declare a built-in or predefined function name as static,
2957              the old definition is overridden, but optionally warn this was a
2958              bad choice of name.  */
2959           if (! TREE_PUBLIC (newdecl))
2960             {
2961               if (warn_shadow)
2962                 cp_warning ("shadowing %s function `%#D'",
2963                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2964                             olddecl);
2965               /* Discard the old built-in function.  */
2966               return 0;
2967             }
2968           /* If the built-in is not ansi, then programs can override
2969              it even globally without an error.  */
2970           else if (! DECL_BUILT_IN (olddecl))
2971             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2972                         olddecl, newdecl);
2973           else
2974             {
2975               cp_error ("declaration of `%#D'", newdecl);
2976               cp_error ("conflicts with built-in declaration `%#D'",
2977                         olddecl);
2978             }
2979           return 0;
2980         }
2981       else if (!types_match)
2982         {
2983           if ((DECL_LANGUAGE (newdecl) == lang_c
2984                && DECL_LANGUAGE (olddecl) == lang_c)
2985               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
2986                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
2987             {
2988               /* A near match; override the builtin.  */
2989
2990               if (TREE_PUBLIC (newdecl))
2991                 {
2992                   cp_warning ("new declaration `%#D'", newdecl);
2993                   cp_warning ("ambiguates built-in declaration `%#D'",
2994                               olddecl);
2995                 }
2996               else if (warn_shadow)
2997                 cp_warning ("shadowing %s function `%#D'",
2998                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2999                             olddecl);
3000             }
3001           else
3002             /* Discard the old built-in function.  */
3003             return 0;
3004         }
3005
3006       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3007         {
3008           /* If a builtin function is redeclared as `static', merge
3009              the declarations, but make the original one static.  */
3010           DECL_THIS_STATIC (olddecl) = 1;
3011           TREE_PUBLIC (olddecl) = 0;
3012
3013           /* Make the olddeclaration consistent with the new one so that
3014              all remnants of the builtin-ness of this function will be
3015              banished.  */
3016           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3017           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3018           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3019           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3020                                        newdecl);
3021         }
3022     }
3023   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3024     {
3025       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3026            && TREE_CODE (newdecl) != TYPE_DECL
3027            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3028                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3029           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3030               && TREE_CODE (olddecl) != TYPE_DECL
3031               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3032                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3033                         == TYPE_DECL))))
3034         {
3035           /* We do nothing special here, because C++ does such nasty
3036              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3037              get shadowed, and know that if we need to find a TYPE_DECL
3038              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3039              slot of the identifier.  */
3040           return 0;
3041         }
3042
3043       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3044            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3045           || (TREE_CODE (olddecl) == FUNCTION_DECL
3046               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3047         return 0;
3048
3049       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3050       if (TREE_CODE (olddecl) == TREE_LIST)
3051         olddecl = TREE_VALUE (olddecl);
3052       cp_error_at ("previous declaration of `%#D'", olddecl);
3053
3054       /* New decl is completely inconsistent with the old one =>
3055          tell caller to replace the old one.  */
3056
3057       return 0;
3058     }
3059   else if (!types_match)
3060     {
3061       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3062         /* These are certainly not duplicate declarations; they're
3063            from different scopes.  */
3064         return 0;
3065
3066       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3067         {
3068           /* The name of a class template may not be declared to refer to
3069              any other template, class, function, object, namespace, value,
3070              or type in the same scope.  */
3071           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3072               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3073             {
3074               cp_error ("declaration of template `%#D'", newdecl);
3075               cp_error_at ("conflicts with previous declaration `%#D'",
3076                            olddecl);
3077             }
3078           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3079                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3080                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3081                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3082                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3083                                            DECL_TEMPLATE_PARMS (olddecl)))
3084             {
3085               cp_error ("new declaration `%#D'", newdecl);
3086               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3087             }
3088           return 0;
3089         }
3090       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3091         {
3092           if (DECL_LANGUAGE (newdecl) == lang_c
3093               && DECL_LANGUAGE (olddecl) == lang_c)
3094             {
3095               cp_error ("declaration of C function `%#D' conflicts with",
3096                         newdecl);
3097               cp_error_at ("previous declaration `%#D' here", olddecl);
3098             }
3099           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3100                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3101             {
3102               cp_error ("new declaration `%#D'", newdecl);
3103               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3104             }
3105           else
3106             return 0;
3107         }
3108
3109       /* Already complained about this, so don't do so again.  */
3110       else if (current_class_type == NULL_TREE
3111           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3112         {
3113           cp_error ("conflicting types for `%#D'", newdecl);
3114           cp_error_at ("previous declaration as `%#D'", olddecl);
3115         }
3116     }
3117   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3118             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3119                  && (!DECL_TEMPLATE_INFO (newdecl)
3120                      || (DECL_TI_TEMPLATE (newdecl)
3121                          != DECL_TI_TEMPLATE (olddecl))))
3122                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3123                     && (!DECL_TEMPLATE_INFO (olddecl)
3124                         || (DECL_TI_TEMPLATE (olddecl)
3125                             != DECL_TI_TEMPLATE (newdecl))))))
3126     /* It's OK to have a template specialization and a non-template
3127        with the same type, or to have specializations of two
3128        different templates with the same type.  Note that if one is a
3129        specialization, and the other is an instantiation of the same
3130        template, that we do not exit at this point.  That situation
3131        can occur if we instantiate a template class, and then
3132        specialize one of its methods.  This situation is legal, but
3133        the declarations must be merged in the usual way.  */
3134     return 0;
3135   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3136            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3137                 && !DECL_USE_TEMPLATE (newdecl))
3138                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3139                    && !DECL_USE_TEMPLATE (olddecl))))
3140     /* One of the declarations is a template instantiation, and the
3141        other is not a template at all.  That's OK.  */
3142     return 0;
3143   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3144            && DECL_NAMESPACE_ALIAS (newdecl)
3145            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3146     /* Redeclaration of namespace alias, ignore it. */
3147     return 1;
3148   else
3149     {
3150       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3151       if (errmsg)
3152         {
3153           cp_error (errmsg, newdecl);
3154           if (DECL_NAME (olddecl) != NULL_TREE)
3155             cp_error_at ((DECL_INITIAL (olddecl)
3156                           && namespace_bindings_p ())
3157                          ? "`%#D' previously defined here"
3158                          : "`%#D' previously declared here", olddecl);
3159         }
3160       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3161                && DECL_INITIAL (olddecl) != NULL_TREE
3162                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3163                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3164         {
3165           /* Prototype decl follows defn w/o prototype.  */
3166           cp_warning_at ("prototype for `%#D'", newdecl);
3167           cp_warning_at ("follows non-prototype definition here", olddecl);
3168         }
3169       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3170                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3171         {
3172           /* extern "C" int foo ();
3173              int foo () { bar (); }
3174              is OK.  */
3175           if (current_lang_stack
3176               == &VARRAY_TREE (current_lang_base, 0))
3177             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3178           else
3179             {
3180               cp_error_at ("previous declaration of `%#D' with %L linkage",
3181                            olddecl, DECL_LANGUAGE (olddecl));
3182               cp_error ("conflicts with new declaration with %L linkage",
3183                         DECL_LANGUAGE (newdecl));
3184             }
3185         }
3186
3187       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3188         ;
3189       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3190         {
3191           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3192           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3193           int i = 1;
3194
3195           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3196             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3197
3198           for (; t1 && t1 != void_list_node;
3199                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3200             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3201               {
3202                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3203                                            TREE_PURPOSE (t2)))
3204                   {
3205                     if (pedantic)
3206                       {
3207                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3208                                     i, newdecl);
3209                         cp_pedwarn_at ("after previous specification in `%#D'",
3210                                        olddecl);
3211                       }
3212                   }
3213                 else
3214                   {
3215                     cp_error ("default argument given for parameter %d of `%#D'",
3216                               i, newdecl);
3217                     cp_error_at ("after previous specification in `%#D'",
3218                                  olddecl);
3219                   }
3220               }
3221
3222           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3223               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3224             {
3225               cp_warning ("`%#D' was used before it was declared inline",
3226                           newdecl);
3227               cp_warning_at ("previous non-inline declaration here",
3228                              olddecl);
3229             }
3230         }
3231     }
3232
3233   /* If new decl is `static' and an `extern' was seen previously,
3234      warn about it.  */
3235   warn_extern_redeclared_static (newdecl, olddecl);
3236
3237   /* We have committed to returning 1 at this point.  */
3238   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3239     {
3240       /* Now that functions must hold information normally held
3241          by field decls, there is extra work to do so that
3242          declaration information does not get destroyed during
3243          definition.  */
3244       if (DECL_VINDEX (olddecl))
3245         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3246       if (DECL_VIRTUAL_CONTEXT (olddecl))
3247         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3248       if (DECL_CONTEXT (olddecl))
3249         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3250       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3251         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3252       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3253       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3254       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3255       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3256       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3257       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3258       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3259
3260       /* Optionally warn about more than one declaration for the same
3261          name, but don't warn about a function declaration followed by a
3262          definition.  */
3263       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3264           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3265           /* Don't warn about extern decl followed by definition. */
3266           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3267           /* Don't warn about friends, let add_friend take care of it. */
3268           && ! DECL_FRIEND_P (newdecl))
3269         {
3270           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3271           cp_warning_at ("previous declaration of `%D'", olddecl);
3272         }
3273     }
3274
3275   /* Deal with C++: must preserve virtual function table size.  */
3276   if (TREE_CODE (olddecl) == TYPE_DECL)
3277     {
3278       register tree newtype = TREE_TYPE (newdecl);
3279       register tree oldtype = TREE_TYPE (olddecl);
3280
3281       if (newtype != error_mark_node && oldtype != error_mark_node
3282           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3283         {
3284           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3285           CLASSTYPE_FRIEND_CLASSES (newtype)
3286             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3287         }
3288     }
3289
3290   /* Copy all the DECL_... slots specified in the new decl
3291      except for any that we copy here from the old type.  */
3292   DECL_MACHINE_ATTRIBUTES (newdecl)
3293     = merge_machine_decl_attributes (olddecl, newdecl);
3294
3295   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3296     {
3297       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3298                              DECL_TEMPLATE_RESULT (olddecl)))
3299         cp_error ("invalid redeclaration of %D", newdecl);
3300       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3301       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3302         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3303                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3304
3305       return 1;
3306     }
3307
3308   if (types_match)
3309     {
3310       /* Automatically handles default parameters.  */
3311       tree oldtype = TREE_TYPE (olddecl);
3312       tree newtype;
3313
3314       /* Merge the data types specified in the two decls.  */
3315       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3316
3317       if (TREE_CODE (newdecl) == VAR_DECL)
3318         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3319       /* Do this after calling `common_type' so that default
3320          parameters don't confuse us.  */
3321       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3322           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3323               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3324         {
3325           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3326                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3327           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3328                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3329
3330           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3331               && DECL_SOURCE_LINE (olddecl) != 0
3332               && flag_exceptions
3333               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3334                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3335             {
3336               cp_error ("declaration of `%F' throws different exceptions",
3337                         newdecl);
3338               cp_error_at ("than previous declaration `%F'", olddecl);
3339             }
3340         }
3341       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3342
3343       /* Lay the type out, unless already done.  */
3344       if (! same_type_p (newtype, oldtype)
3345           && TREE_TYPE (newdecl) != error_mark_node
3346           && !(processing_template_decl && uses_template_parms (newdecl)))
3347         layout_type (TREE_TYPE (newdecl));
3348
3349       if ((TREE_CODE (newdecl) == VAR_DECL
3350            || TREE_CODE (newdecl) == PARM_DECL
3351            || TREE_CODE (newdecl) == RESULT_DECL
3352            || TREE_CODE (newdecl) == FIELD_DECL
3353            || TREE_CODE (newdecl) == TYPE_DECL)
3354           && !(processing_template_decl && uses_template_parms (newdecl)))
3355         layout_decl (newdecl, 0);
3356
3357       /* Merge the type qualifiers.  */
3358       if (TREE_READONLY (newdecl))
3359         TREE_READONLY (olddecl) = 1;
3360       if (TREE_THIS_VOLATILE (newdecl))
3361         TREE_THIS_VOLATILE (olddecl) = 1;
3362
3363       /* Merge the initialization information.  */
3364       if (DECL_INITIAL (newdecl) == NULL_TREE
3365           && DECL_INITIAL (olddecl) != NULL_TREE)
3366         {
3367           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3368           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3369           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3370           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3371               && DECL_LANG_SPECIFIC (newdecl)
3372               && DECL_LANG_SPECIFIC (olddecl))
3373             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3374         }
3375
3376       /* Merge the section attribute.
3377          We want to issue an error if the sections conflict but that must be
3378          done later in decl_attributes since we are called before attributes
3379          are assigned.  */
3380       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3381         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3382
3383       /* Keep the old rtl since we can safely use it.  */
3384       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3385
3386       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3387         {
3388           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3389             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3390           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3391             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3392           DECL_NO_LIMIT_STACK (newdecl)
3393             |= DECL_NO_LIMIT_STACK (olddecl);
3394         }
3395     }
3396   /* If cannot merge, then use the new type and qualifiers,
3397      and don't preserve the old rtl.  */
3398   else
3399     {
3400       /* Clean out any memory we had of the old declaration.  */
3401       tree oldstatic = value_member (olddecl, static_aggregates);
3402       if (oldstatic)
3403         TREE_VALUE (oldstatic) = error_mark_node;
3404
3405       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3406       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3407       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3408       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3409     }
3410
3411   /* Merge the storage class information.  */
3412   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3413   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3414   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3415   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3416   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3417   if (! DECL_EXTERNAL (olddecl))
3418     DECL_EXTERNAL (newdecl) = 0;
3419
3420   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3421     {
3422       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3423       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3424       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3425       DECL_TEMPLATE_INSTANTIATED (newdecl)
3426         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3427       /* Don't really know how much of the language-specific
3428          values we should copy from old to new.  */
3429       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3430       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3431       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3432       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3433       olddecl_friend = DECL_FRIEND_P (olddecl);
3434
3435       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3436       if (TREE_CODE (newdecl) == FUNCTION_DECL
3437           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3438         DECL_BEFRIENDING_CLASSES (newdecl)
3439           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3440                      DECL_BEFRIENDING_CLASSES (olddecl));
3441     }
3442
3443   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3444     {
3445       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3446           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3447         {
3448           /* If newdecl is not a specialization, then it is not a
3449              template-related function at all.  And that means that we
3450              shoud have exited above, returning 0.  */
3451           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3452                               0);
3453
3454           if (TREE_USED (olddecl))
3455             /* From [temp.expl.spec]:
3456
3457                If a template, a member template or the member of a class
3458                template is explicitly specialized then that
3459                specialization shall be declared before the first use of
3460                that specialization that would cause an implicit
3461                instantiation to take place, in every translation unit in
3462                which such a use occurs.  */
3463             cp_error ("explicit specialization of %D after first use",
3464                       olddecl);
3465
3466           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3467         }
3468       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3469
3470       /* If either decl says `inline', this fn is inline, unless its
3471          definition was passed already.  */
3472       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3473         DECL_INLINE (olddecl) = 1;
3474       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3475
3476       if (! types_match)
3477         {
3478           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3479           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3480           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3481         }
3482       if (! types_match || new_defines_function)
3483         {
3484           /* These need to be copied so that the names are available.
3485              Note that if the types do match, we'll preserve inline
3486              info and other bits, but if not, we won't.  */
3487           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3488           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3489         }
3490       if (new_defines_function)
3491         /* If defining a function declared with other language
3492            linkage, use the previously declared language linkage.  */
3493         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3494       else if (types_match)
3495         {
3496           /* If redeclaring a builtin function, and not a definition,
3497              it stays built in.  */
3498           if (DECL_BUILT_IN (olddecl))
3499             {
3500               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3501               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3502               /* If we're keeping the built-in definition, keep the rtl,
3503                  regardless of declaration matches.  */
3504               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3505             }
3506           else
3507             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3508
3509           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3510           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3511             /* Previously saved insns go together with
3512                the function's previous definition.  */
3513             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3514           /* Don't clear out the arguments if we're redefining a function.  */
3515           if (DECL_ARGUMENTS (olddecl))
3516             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3517         }
3518       if (DECL_LANG_SPECIFIC (olddecl))
3519         DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
3520     }
3521
3522   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3523     {
3524       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3525     }
3526
3527   /* Now preserve various other info from the definition.  */
3528   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3529   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3530   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3531   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3532
3533   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3534     {
3535       int function_size;
3536
3537       function_size = sizeof (struct tree_decl);
3538
3539       bcopy ((char *) newdecl + sizeof (struct tree_common),
3540              (char *) olddecl + sizeof (struct tree_common),
3541              function_size - sizeof (struct tree_common));
3542
3543       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3544         {
3545           /* If newdecl is a template instantiation, it is possible that
3546              the following sequence of events has occurred:
3547
3548              o A friend function was declared in a class template.  The
3549              class template was instantiated.
3550
3551              o The instantiation of the friend declaration was
3552              recorded on the instantiation list, and is newdecl.
3553
3554              o Later, however, instantiate_class_template called pushdecl
3555              on the newdecl to perform name injection.  But, pushdecl in
3556              turn called duplicate_decls when it discovered that another
3557              declaration of a global function with the same name already
3558              existed.
3559
3560              o Here, in duplicate_decls, we decided to clobber newdecl.
3561
3562              If we're going to do that, we'd better make sure that
3563              olddecl, and not newdecl, is on the list of
3564              instantiations so that if we try to do the instantiation
3565              again we won't get the clobbered declaration.  */
3566
3567           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3568           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3569
3570           for (; decls; decls = TREE_CHAIN (decls))
3571             if (TREE_VALUE (decls) == newdecl)
3572               TREE_VALUE (decls) = olddecl;
3573         }
3574     }
3575   else
3576     {
3577       bcopy ((char *) newdecl + sizeof (struct tree_common),
3578              (char *) olddecl + sizeof (struct tree_common),
3579              sizeof (struct tree_decl) - sizeof (struct tree_common)
3580              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3581     }
3582
3583   DECL_UID (olddecl) = olddecl_uid;
3584   if (olddecl_friend)
3585     DECL_FRIEND_P (olddecl) = 1;
3586
3587   /* NEWDECL contains the merged attribute lists.
3588      Update OLDDECL to be the same.  */
3589   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3590
3591   return 1;
3592 }
3593
3594 /* Record a decl-node X as belonging to the current lexical scope.
3595    Check for errors (such as an incompatible declaration for the same
3596    name already seen in the same scope).
3597
3598    Returns either X or an old decl for the same name.
3599    If an old decl is returned, it may have been smashed
3600    to agree with what X says.  */
3601
3602 tree
3603 pushdecl (x)
3604      tree x;
3605 {
3606   register tree t;
3607   register tree name;
3608   int need_new_binding;
3609
3610   /* We shouldn't be calling pushdecl when we're generating RTL for a
3611      function that we already did semantic analysis on previously.  */
3612   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3613                       19990913);
3614
3615   name = DECL_ASSEMBLER_NAME (x);
3616   need_new_binding = 1;
3617
3618   if (DECL_TEMPLATE_PARM_P (x))
3619     /* Template parameters have no context; they are not X::T even
3620        when declared within a class or namespace.  */
3621     ;
3622   else
3623     {
3624       if (current_function_decl && x != current_function_decl
3625           /* A local declaration for a function doesn't constitute
3626              nesting.  */
3627           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3628           /* A local declaration for an `extern' variable is in the
3629              scoped of the current namespace, not the current
3630              function.  */
3631           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3632           && !DECL_CONTEXT (x))
3633         DECL_CONTEXT (x) = current_function_decl;
3634       if (!DECL_CONTEXT (x))
3635         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3636
3637       /* If this is the declaration for a namespace-scope function,
3638          but the declaration itself is in a local scope, mark the
3639          declaration.  */
3640       if (TREE_CODE (x) == FUNCTION_DECL
3641           && DECL_NAMESPACE_SCOPE_P (x)
3642           && current_function_decl
3643           && x != current_function_decl)
3644         DECL_LOCAL_FUNCTION_P (x) = 1;
3645     }
3646
3647   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3648      compiler wants to use.  */
3649   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3650       || TREE_CODE (x) == NAMESPACE_DECL)
3651     name = DECL_NAME (x);
3652
3653   if (name)
3654     {
3655 #if 0
3656       /* Not needed...see below.  */
3657       char *file;
3658       int line;
3659 #endif
3660       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3661         name = TREE_OPERAND (name, 0);
3662
3663       /* Namespace-scoped variables are not found in the current level. */
3664       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3665         t = namespace_binding (name, DECL_CONTEXT (x));
3666       else
3667         t = lookup_name_current_level (name);
3668       if (t == error_mark_node)
3669         {
3670           /* error_mark_node is 0 for a while during initialization!  */
3671           t = NULL_TREE;
3672           cp_error_at ("`%#D' used prior to declaration", x);
3673         }
3674
3675       else if (t != NULL_TREE)
3676         {
3677 #if 0
3678           /* This is turned off until I have time to do it right (bpk).  */
3679           /* With the code below that uses it...  */
3680           file = DECL_SOURCE_FILE (t);
3681           line = DECL_SOURCE_LINE (t);
3682 #endif
3683           if (TREE_CODE (t) == PARM_DECL)
3684             {
3685               if (DECL_CONTEXT (t) == NULL_TREE)
3686                 fatal ("parse errors have confused me too much");
3687
3688               /* Check for duplicate params.  */
3689               if (duplicate_decls (x, t))
3690                 return t;
3691             }
3692           else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3693                     || DECL_FUNCTION_TEMPLATE_P (x))
3694                    && is_overloaded_fn (t))
3695             /* Don't do anything just yet. */;
3696           else if (t == wchar_decl_node)
3697             {
3698               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3699                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3700
3701               /* Throw away the redeclaration.  */
3702               return t;
3703             }
3704           else if (TREE_CODE (t) != TREE_CODE (x))
3705             {
3706               if (duplicate_decls (x, t))
3707                 return t;
3708             }
3709           else if (duplicate_decls (x, t))
3710             {
3711 #if 0
3712               /* This is turned off until I have time to do it right (bpk).  */
3713
3714               /* Also warn if they did a prototype with `static' on it, but
3715                  then later left the `static' off.  */
3716               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3717                 {
3718                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3719                     return t;
3720
3721                   if (extra_warnings)
3722                     {
3723                       cp_warning ("`static' missing from declaration of `%D'",
3724                                   t);
3725                       warning_with_file_and_line (file, line,
3726                                                   "previous declaration of `%s'",
3727                                                   decl_as_string (t, 0));
3728                     }
3729
3730                   /* Now fix things so it'll do what they expect.  */
3731                   if (current_function_decl)
3732                     TREE_PUBLIC (current_function_decl) = 0;
3733                 }
3734               /* Due to interference in memory reclamation (X may be
3735                  obstack-deallocated at this point), we must guard against
3736                  one really special case.  [jason: This should be handled
3737                  by start_function]  */
3738               if (current_function_decl == x)
3739                 current_function_decl = t;
3740 #endif
3741               if (TREE_CODE (t) == TYPE_DECL)
3742                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3743               else if (TREE_CODE (t) == FUNCTION_DECL)
3744                 check_default_args (t);
3745
3746               return t;
3747             }
3748           else if (DECL_MAIN_P (x))
3749             {
3750               /* A redeclaration of main, but not a duplicate of the
3751                  previous one.
3752
3753                  [basic.start.main]
3754
3755                  This function shall not be overloaded.  */
3756               cp_error_at ("invalid redeclaration of `%D'", t);
3757               cp_error ("as `%D'", x);
3758               /* We don't try to push this declaration since that
3759                  causes a crash.  */
3760               return x;
3761             }
3762         }
3763
3764       check_template_shadow (x);
3765
3766       /* If this is a function conjured up by the backend, massage it
3767          so it looks friendly.  */
3768       if (TREE_CODE (x) == FUNCTION_DECL
3769           && ! DECL_LANG_SPECIFIC (x))
3770         {
3771           retrofit_lang_decl (x);
3772           DECL_LANGUAGE (x) = lang_c;
3773         }
3774
3775       if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3776         {
3777           t = push_overloaded_decl (x, PUSH_LOCAL);
3778           if (t != x)
3779             return t;
3780           if (!namespace_bindings_p ())
3781             /* We do not need to create a binding for this name;
3782                push_overloaded_decl will have already done so if
3783                necessary.  */
3784             need_new_binding = 0;
3785         }
3786       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3787         {
3788           t = push_overloaded_decl (x, PUSH_GLOBAL);
3789           if (t == x)
3790             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3791           return t;
3792         }
3793
3794       /* If declaring a type as a typedef, copy the type (unless we're
3795          at line 0), and install this TYPE_DECL as the new type's typedef
3796          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3797       if (TREE_CODE (x) == TYPE_DECL)
3798         {
3799           tree type = TREE_TYPE (x);
3800           if (DECL_SOURCE_LINE (x) == 0)
3801             {
3802               if (TYPE_NAME (type) == 0)
3803                 TYPE_NAME (type) = x;
3804             }
3805           else if (type != error_mark_node && TYPE_NAME (type) != x
3806                    /* We don't want to copy the type when all we're
3807                       doing is making a TYPE_DECL for the purposes of
3808                       inlining.  */
3809                    && (!TYPE_NAME (type)
3810                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3811             {
3812               DECL_ORIGINAL_TYPE (x) = type;
3813               type = build_type_copy (type);
3814               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3815               TYPE_NAME (type) = x;
3816               TREE_TYPE (x) = type;
3817             }
3818
3819           if (type != error_mark_node
3820               && TYPE_NAME (type)
3821               && TYPE_IDENTIFIER (type))
3822             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3823                                                   current_binding_level);
3824
3825         }
3826
3827       /* Multiple external decls of the same identifier ought to match.
3828
3829          We get warnings about inline functions where they are defined.
3830          We get warnings about other functions from push_overloaded_decl.
3831
3832          Avoid duplicate warnings where they are used.  */
3833       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3834         {
3835           tree decl;
3836
3837           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3838               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3839                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3840             decl = IDENTIFIER_NAMESPACE_VALUE (name);
3841           else
3842             decl = NULL_TREE;
3843
3844           if (decl
3845               /* If different sort of thing, we already gave an error.  */
3846               && TREE_CODE (decl) == TREE_CODE (x)
3847               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3848             {
3849               cp_pedwarn ("type mismatch with previous external decl", x);
3850               cp_pedwarn_at ("previous external decl of `%#D'", decl);
3851             }
3852         }
3853
3854       /* This name is new in its binding level.
3855          Install the new declaration and return it.  */
3856       if (namespace_bindings_p ())
3857         {
3858           /* Install a global value.  */
3859
3860           /* If the first global decl has external linkage,
3861              warn if we later see static one.  */
3862           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3863             TREE_PUBLIC (name) = 1;
3864
3865           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3866                 && t != NULL_TREE)
3867               /* For an ordinary function, we create a binding from
3868                  the mangled name (i.e., NAME) to the DECL.  But, for
3869                  an `extern "C"' function, the mangled name and the
3870                  ordinary name are the same so we need not do this.  */
3871               && !(TREE_CODE (x) == FUNCTION_DECL &&
3872                    DECL_LANGUAGE (x) == lang_c))
3873             {
3874               if (TREE_CODE (x) == FUNCTION_DECL)
3875                 my_friendly_assert
3876                   ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
3877                   || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
3878               SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3879             }
3880
3881           /* Don't forget if the function was used via an implicit decl.  */
3882           if (IDENTIFIER_IMPLICIT_DECL (name)
3883               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3884             TREE_USED (x) = 1;
3885
3886           /* Don't forget if its address was taken in that way.  */
3887           if (IDENTIFIER_IMPLICIT_DECL (name)
3888               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3889             TREE_ADDRESSABLE (x) = 1;
3890
3891           /* Warn about mismatches against previous implicit decl.  */
3892           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
3893               /* If this real decl matches the implicit, don't complain.  */
3894               && ! (TREE_CODE (x) == FUNCTION_DECL
3895                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
3896             cp_warning
3897               ("`%D' was previously implicitly declared to return `int'", x);
3898
3899           /* If new decl is `static' and an `extern' was seen previously,
3900              warn about it.  */
3901           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
3902             warn_extern_redeclared_static (x, t);
3903         }
3904       else
3905         {
3906           /* Here to install a non-global value.  */
3907           tree oldlocal = IDENTIFIER_VALUE (name);
3908           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
3909
3910           if (need_new_binding)
3911             {
3912               push_local_binding (name, x, 0);
3913               /* Because push_local_binding will hook X on to the
3914                  current_binding_level's name list, we don't want to
3915                  do that again below.  */
3916               need_new_binding = 0;
3917             }
3918
3919           /* If this is a TYPE_DECL, push it into the type value slot.  */
3920           if (TREE_CODE (x) == TYPE_DECL)
3921             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
3922                                                   current_binding_level);
3923
3924           /* Clear out any TYPE_DECL shadowed by a namespace so that
3925              we won't think this is a type.  The C struct hack doesn't
3926              go through namespaces.  */
3927           if (TREE_CODE (x) == NAMESPACE_DECL)
3928             set_identifier_type_value_with_scope (name, NULL_TREE,
3929                                                   current_binding_level);
3930
3931           if (oldlocal)
3932             {
3933               tree d = oldlocal;
3934               while (oldlocal
3935                      && TREE_CODE (oldlocal) == VAR_DECL
3936                      && DECL_DEAD_FOR_LOCAL (oldlocal))
3937                 {
3938                   oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
3939                 }
3940               if (oldlocal == NULL_TREE)
3941                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
3942             }
3943
3944           /* If this is an extern function declaration, see if we
3945              have a global definition or declaration for the function.  */
3946           if (oldlocal == NULL_TREE
3947               && DECL_EXTERNAL (x)
3948               && oldglobal != NULL_TREE
3949               && TREE_CODE (x) == FUNCTION_DECL
3950               && TREE_CODE (oldglobal) == FUNCTION_DECL)
3951             {
3952               /* We have one.  Their types must agree.  */
3953               if (decls_match (x, oldglobal))
3954                 /* OK */;
3955               else
3956                 {
3957                   cp_warning ("extern declaration of `%#D' doesn't match", x);
3958                   cp_warning_at ("global declaration `%#D'", oldglobal);
3959                 }
3960             }
3961           /* If we have a local external declaration,
3962              and no file-scope declaration has yet been seen,
3963              then if we later have a file-scope decl it must not be static.  */
3964           if (oldlocal == NULL_TREE
3965               && oldglobal == NULL_TREE
3966               && DECL_EXTERNAL (x)
3967               && TREE_PUBLIC (x))
3968             TREE_PUBLIC (name) = 1;
3969
3970           /* Warn if shadowing an argument at the top level of the body.  */
3971           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
3972               /* Inline decls shadow nothing.  */
3973               && !DECL_FROM_INLINE (x)
3974               && TREE_CODE (oldlocal) == PARM_DECL
3975               /* Don't complain if it's from an enclosing function.  */
3976               && DECL_CONTEXT (oldlocal) == current_function_decl
3977               && TREE_CODE (x) != PARM_DECL)
3978             {
3979               /* Go to where the parms should be and see if we
3980                  find them there.  */
3981               struct binding_level *b = current_binding_level->level_chain;
3982
3983               if (cleanup_label)
3984                 b = b->level_chain;
3985
3986               /* ARM $8.3 */
3987               if (b->parm_flag == 1)
3988                 cp_error ("declaration of `%#D' shadows a parameter", name);
3989             }
3990
3991           /* Maybe warn if shadowing something else.  */
3992           if (warn_shadow && !DECL_EXTERNAL (x)
3993               /* Inline decls shadow nothing.  */
3994               && !DECL_FROM_INLINE (x)
3995               /* No shadow warnings for internally generated vars.  */
3996               && ! DECL_ARTIFICIAL (x)
3997               /* No shadow warnings for vars made for inlining.  */
3998               && ! DECL_FROM_INLINE (x))
3999             {
4000               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4001                 warning ("declaration of `%s' shadows a parameter",
4002                         IDENTIFIER_POINTER (name));
4003               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4004                        && current_class_ptr
4005                        && !TREE_STATIC (name))
4006                 warning ("declaration of `%s' shadows a member of `this'",
4007                         IDENTIFIER_POINTER (name));
4008               else if (oldlocal != NULL_TREE)
4009                 warning ("declaration of `%s' shadows previous local",
4010                         IDENTIFIER_POINTER (name));
4011               else if (oldglobal != NULL_TREE)
4012                 /* XXX shadow warnings in outer-more namespaces */
4013                 warning ("declaration of `%s' shadows global declaration",
4014                         IDENTIFIER_POINTER (name));
4015             }
4016         }
4017
4018       if (TREE_CODE (x) == FUNCTION_DECL)
4019         check_default_args (x);
4020
4021       /* Keep count of variables in this level with incomplete type.  */
4022       if (TREE_CODE (x) == VAR_DECL
4023           && TREE_TYPE (x) != error_mark_node
4024           && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
4025                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4026               /* RTTI TD entries are created while defining the type_info.  */
4027               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4028                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4029         {
4030           if (namespace_bindings_p ())
4031             namespace_scope_incomplete
4032               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4033           else
4034             current_binding_level->incomplete
4035               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4036         }
4037     }
4038
4039   if (need_new_binding)
4040     add_decl_to_level (x,
4041                        DECL_NAMESPACE_SCOPE_P (x)
4042                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4043                        : current_binding_level);
4044
4045   return x;
4046 }
4047
4048 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4049    caller to set DECL_CONTEXT properly.  */
4050
4051 static tree
4052 pushdecl_with_scope (x, level)
4053      tree x;
4054      struct binding_level *level;
4055 {
4056   register struct binding_level *b;
4057   tree function_decl = current_function_decl;
4058
4059   current_function_decl = NULL_TREE;
4060   if (level->parm_flag == 2)
4061     {
4062       b = class_binding_level;
4063       class_binding_level = level;
4064       pushdecl_class_level (x);
4065       class_binding_level = b;
4066     }
4067   else
4068     {
4069       b = current_binding_level;
4070       current_binding_level = level;
4071       x = pushdecl (x);
4072       current_binding_level = b;
4073     }
4074   current_function_decl = function_decl;
4075   return x;
4076 }
4077
4078 /* Like pushdecl, only it places X in the current namespace,
4079    if appropriate.  */
4080
4081 tree
4082 pushdecl_namespace_level (x)
4083      tree x;
4084 {
4085   register struct binding_level *b = current_binding_level;
4086   register tree t;
4087
4088   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4089
4090   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4091      what we want.  */
4092   if (TREE_CODE (x) == TYPE_DECL)
4093     {
4094       tree name = DECL_NAME (x);
4095       tree newval;
4096       tree *ptr = (tree *)0;
4097       for (; b != global_binding_level; b = b->level_chain)
4098         {
4099           tree shadowed = b->type_shadowed;
4100           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4101             if (TREE_PURPOSE (shadowed) == name)
4102               {
4103                 ptr = &TREE_VALUE (shadowed);
4104                 /* Can't break out of the loop here because sometimes
4105                    a binding level will have duplicate bindings for
4106                    PT names.  It's gross, but I haven't time to fix it.  */
4107               }
4108         }
4109       newval = TREE_TYPE (x);
4110       if (ptr == (tree *)0)
4111         {
4112           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4113              up here if this is changed to an assertion.  --KR  */
4114           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4115         }
4116       else
4117         {
4118           *ptr = newval;
4119         }
4120     }
4121   return t;
4122 }
4123
4124 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4125    if appropriate.  */
4126
4127 tree
4128 pushdecl_top_level (x)
4129      tree x;
4130 {
4131   push_to_top_level ();
4132   x = pushdecl_namespace_level (x);
4133   pop_from_top_level ();
4134   return x;
4135 }
4136
4137 /* Make the declaration of X appear in CLASS scope.  */
4138
4139 void
4140 pushdecl_class_level (x)
4141      tree x;
4142 {
4143   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4144      scope looks for the pre-mangled name.  */
4145   register tree name;
4146
4147   if (TREE_CODE (x) == OVERLOAD)
4148     x = OVL_CURRENT (x);
4149   name = DECL_NAME (x);
4150
4151   if (name)
4152     {
4153       push_class_level_binding (name, x);
4154       if (TREE_CODE (x) == TYPE_DECL)
4155         set_identifier_type_value (name, TREE_TYPE (x));
4156     }
4157   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4158     {
4159       tree f;
4160
4161       for (f = TYPE_FIELDS (TREE_TYPE (x));
4162            f;
4163            f = TREE_CHAIN (f))
4164         pushdecl_class_level (f);
4165     }
4166 }
4167
4168 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4169    DECL, or a modified version thereof.  */
4170
4171 tree
4172 maybe_push_decl (decl)
4173      tree decl;
4174 {
4175   tree type = TREE_TYPE (decl);
4176
4177   /* Add this decl to the current binding level, but not if it comes
4178      from another scope, e.g. a static member variable.  TEM may equal
4179      DECL or it may be a previous decl of the same name.  */
4180   if (decl == error_mark_node
4181       || (TREE_CODE (decl) != PARM_DECL
4182           && DECL_CONTEXT (decl) != NULL_TREE
4183           /* Definitions of namespace members outside their namespace are
4184              possible. */
4185           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4186       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4187       || TREE_CODE (type) == UNKNOWN_TYPE
4188       /* The declaration of a template specialization does not affect
4189          the functions available for overload resolution, so we do not
4190          call pushdecl.  */
4191       || (TREE_CODE (decl) == FUNCTION_DECL
4192           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4193     return decl;
4194   else
4195     return pushdecl (decl);
4196 }
4197
4198 #if 0
4199 /* This function is used to push the mangled decls for nested types into
4200    the appropriate scope.  Previously pushdecl_top_level was used, but that
4201    is incorrect for members of local classes.  */
4202
4203 void
4204 pushdecl_nonclass_level (x)
4205      tree x;
4206 {
4207   struct binding_level *b = current_binding_level;
4208
4209   my_friendly_assert (b->parm_flag != 2, 180);
4210
4211 #if 0
4212   /* Get out of template binding levels */
4213   while (b->pseudo_global)
4214     b = b->level_chain;
4215 #endif
4216
4217   pushdecl_with_scope (x, b);
4218 }
4219 #endif
4220
4221 /* Make the declaration(s) of X appear in CLASS scope
4222    under the name NAME.  */
4223
4224 void
4225 push_class_level_binding (name, x)
4226      tree name;
4227      tree x;
4228 {
4229   tree binding;
4230   /* The class_binding_level will be NULL if x is a template
4231      parameter name in a member template.  */
4232   if (!class_binding_level)
4233     return;
4234
4235   /* Make sure that this new member does not have the same name
4236      as a template parameter.  */
4237   if (TYPE_BEING_DEFINED (current_class_type))
4238     check_template_shadow (x);
4239
4240   /* If this declaration shadows a declaration from an enclosing
4241      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4242      we leave this class.  Record the shadowed declaration here.  */
4243   binding = IDENTIFIER_BINDING (name);
4244   if (binding
4245       && ((TREE_CODE (x) == OVERLOAD
4246            && BINDING_VALUE (binding)
4247            && is_overloaded_fn (BINDING_VALUE (binding)))
4248           || INHERITED_VALUE_BINDING_P (binding)))
4249     {
4250       tree shadow;
4251       tree old_decl;
4252
4253       /* If the old binding was from a base class, and was for a tag
4254          name, slide it over to make room for the new binding.  The
4255          old binding is still visible if explicitly qualified with a
4256          class-key.  */
4257       if (INHERITED_VALUE_BINDING_P (binding)
4258           && BINDING_VALUE (binding)
4259           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4260           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4261           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4262         {
4263           old_decl = BINDING_TYPE (binding);
4264           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4265           BINDING_VALUE (binding) = NULL_TREE;
4266           INHERITED_VALUE_BINDING_P (binding) = 0;
4267         }
4268       else
4269         old_decl = BINDING_VALUE (binding);
4270
4271       /* There was already a binding for X containing fewer
4272          functions than are named in X.  Find the previous
4273          declaration of X on the class-shadowed list, and update it.  */
4274       for (shadow = class_binding_level->class_shadowed;
4275            shadow;
4276            shadow = TREE_CHAIN (shadow))
4277         if (TREE_PURPOSE (shadow) == name
4278             && TREE_TYPE (shadow) == old_decl)
4279           {
4280             BINDING_VALUE (binding) = x;
4281             INHERITED_VALUE_BINDING_P (binding) = 0;
4282             TREE_TYPE (shadow) = x;
4283             return;
4284           }
4285     }
4286
4287   /* If we didn't replace an existing binding, put the binding on the
4288      stack of bindings for the identifier, and update
4289      IDENTIFIER_CLASS_VALUE.  */
4290   if (push_class_binding (name, x))
4291     {
4292       class_binding_level->class_shadowed
4293         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4294                      class_binding_level->class_shadowed);
4295       /* Record the value we are binding NAME to so that we can know
4296          what to pop later.  */
4297       TREE_TYPE (class_binding_level->class_shadowed) = x;
4298     }
4299 }
4300
4301 /* Insert another USING_DECL into the current binding level,
4302    returning this declaration. If this is a redeclaration,
4303    do nothing and return NULL_TREE.  */
4304
4305 tree
4306 push_using_decl (scope, name)
4307      tree scope;
4308      tree name;
4309 {
4310   tree decl;
4311
4312   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4313   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4314   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4315     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4316       break;
4317   if (decl)
4318     return NULL_TREE;
4319   decl = build_lang_decl (USING_DECL, name, void_type_node);
4320   DECL_INITIAL (decl) = scope;
4321   TREE_CHAIN (decl) = current_binding_level->usings;
4322   current_binding_level->usings = decl;
4323   return decl;
4324 }
4325
4326 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4327    changed (i.e. there was already a directive), or the fresh
4328    TREE_LIST otherwise.  */
4329
4330 tree
4331 push_using_directive (used)
4332      tree used;
4333 {
4334   tree ud = current_binding_level->using_directives;
4335   tree iter, ancestor;
4336
4337   /* Check if we already have this. */
4338   if (purpose_member (used, ud) != NULL_TREE)
4339     return NULL_TREE;
4340
4341   /* Recursively add all namespaces used. */
4342   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4343     push_using_directive (TREE_PURPOSE (iter));
4344
4345   ancestor = namespace_ancestor (current_decl_namespace (), used);
4346   ud = current_binding_level->using_directives;
4347   ud = tree_cons (used, ancestor, ud);
4348   current_binding_level->using_directives = ud;
4349   return ud;
4350 }
4351
4352 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4353    other definitions already in place.  We get around this by making
4354    the value of the identifier point to a list of all the things that
4355    want to be referenced by that name.  It is then up to the users of
4356    that name to decide what to do with that list.
4357
4358    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4359    slot.  It is dealt with the same way.
4360
4361    FLAGS is a bitwise-or of the following values:
4362      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4363                  namespace scope.
4364      PUSH_USING: DECL is being pushed as the result of a using
4365                  declaration.
4366
4367    The value returned may be a previous declaration if we guessed wrong
4368    about what language DECL should belong to (C or C++).  Otherwise,
4369    it's always DECL (and never something that's not a _DECL).  */
4370
4371 tree
4372 push_overloaded_decl (decl, flags)
4373      tree decl;
4374      int flags;
4375 {
4376   tree name = DECL_NAME (decl);
4377   tree old;
4378   tree new_binding;
4379   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4380
4381   if (doing_global)
4382     old = namespace_binding (name, DECL_CONTEXT (decl));
4383   else
4384     old = lookup_name_current_level (name);
4385
4386   if (old)
4387     {
4388       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4389         {
4390           tree t = TREE_TYPE (old);
4391           if (IS_AGGR_TYPE (t) && warn_shadow
4392               && (! DECL_IN_SYSTEM_HEADER (decl)
4393                   || ! DECL_IN_SYSTEM_HEADER (old)))
4394             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4395           old = NULL_TREE;
4396         }
4397       else if (is_overloaded_fn (old))
4398         {
4399           tree tmp;
4400
4401           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4402             {
4403               tree fn = OVL_CURRENT (tmp);
4404
4405               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4406                   && !(flags & PUSH_USING)
4407                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4408                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4409                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4410                           decl, fn);
4411
4412               if (duplicate_decls (decl, fn))
4413                 return fn;
4414             }
4415         }
4416       else
4417         {
4418           cp_error_at ("previous non-function declaration `%#D'", old);
4419           cp_error ("conflicts with function declaration `%#D'", decl);
4420           return decl;
4421         }
4422     }
4423
4424   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4425     {
4426       if (old && TREE_CODE (old) != OVERLOAD)
4427         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4428       else
4429         new_binding = ovl_cons (decl, old);
4430       if (flags & PUSH_USING)
4431         OVL_USED (new_binding) = 1;
4432     }
4433   else
4434     /* NAME is not ambiguous.  */
4435     new_binding = decl;
4436
4437   if (doing_global)
4438     set_namespace_binding (name, current_namespace, new_binding);
4439   else
4440     {
4441       /* We only create an OVERLOAD if there was a previous binding at
4442          this level, or if decl is a template. In the former case, we
4443          need to remove the old binding and replace it with the new
4444          binding.  We must also run through the NAMES on the binding
4445          level where the name was bound to update the chain.  */
4446
4447       if (TREE_CODE (new_binding) == OVERLOAD && old)
4448         {
4449           tree *d;
4450
4451           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4452                *d;
4453                d = &TREE_CHAIN (*d))
4454             if (*d == old
4455                 || (TREE_CODE (*d) == TREE_LIST
4456                     && TREE_VALUE (*d) == old))
4457               {
4458                 if (TREE_CODE (*d) == TREE_LIST)
4459                   /* Just replace the old binding with the new.  */
4460                   TREE_VALUE (*d) = new_binding;
4461                 else
4462                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4463                   *d = tree_cons (NULL_TREE, new_binding,
4464                                   TREE_CHAIN (*d));
4465
4466                 /* And update the CPLUS_BINDING node.  */
4467                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4468                   = new_binding;
4469                 return decl;
4470               }
4471
4472           /* We should always find a previous binding in this case.  */
4473           my_friendly_abort (0);
4474         }
4475
4476       /* Install the new binding.  */
4477       push_local_binding (name, new_binding, flags);
4478     }
4479
4480   return decl;
4481 }
4482 \f
4483 /* Generate an implicit declaration for identifier FUNCTIONID
4484    as a function of type int ().  Print a warning if appropriate.  */
4485
4486 tree
4487 implicitly_declare (functionid)
4488      tree functionid;
4489 {
4490   register tree decl;
4491
4492   /* We used to reuse an old implicit decl here,
4493      but this loses with inline functions because it can clobber
4494      the saved decl chains.  */
4495   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4496
4497   DECL_EXTERNAL (decl) = 1;
4498   TREE_PUBLIC (decl) = 1;
4499
4500   /* ISO standard says implicit declarations are in the innermost block.
4501      So we record the decl in the standard fashion.  */
4502   pushdecl (decl);
4503   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4504
4505   if (warn_implicit
4506       /* Only one warning per identifier.  */
4507       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4508     {
4509       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4510     }
4511
4512   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4513
4514   return decl;
4515 }
4516
4517 /* Return zero if the declaration NEWDECL is valid
4518    when the declaration OLDDECL (assumed to be for the same name)
4519    has already been seen.
4520    Otherwise return an error message format string with a %s
4521    where the identifier should go.  */
4522
4523 static const char *
4524 redeclaration_error_message (newdecl, olddecl)
4525      tree newdecl, olddecl;
4526 {
4527   if (TREE_CODE (newdecl) == TYPE_DECL)
4528     {
4529       /* Because C++ can put things into name space for free,
4530          constructs like "typedef struct foo { ... } foo"
4531          would look like an erroneous redeclaration.  */
4532       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4533         return 0;
4534       else
4535         return "redefinition of `%#D'";
4536     }
4537   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4538     {
4539       /* If this is a pure function, its olddecl will actually be
4540          the original initialization to `0' (which we force to call
4541          abort()).  Don't complain about redefinition in this case.  */
4542       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4543         return 0;
4544
4545       /* If both functions come from different namespaces, this is not
4546          a redeclaration - this is a conflict with a used function. */
4547       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4548           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4549         return "`%D' conflicts with used function";
4550
4551       /* We'll complain about linkage mismatches in
4552          warn_extern_redeclared_static.  */
4553
4554       /* Defining the same name twice is no good.  */
4555       if (DECL_INITIAL (olddecl) != NULL_TREE
4556           && DECL_INITIAL (newdecl) != NULL_TREE)
4557         {
4558           if (DECL_NAME (olddecl) == NULL_TREE)
4559             return "`%#D' not declared in class";
4560           else
4561             return "redefinition of `%#D'";
4562         }
4563       return 0;
4564     }
4565   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4566     {
4567       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4568            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4569            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4570           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4571               && TYPE_SIZE (TREE_TYPE (newdecl))
4572               && TYPE_SIZE (TREE_TYPE (olddecl))))
4573         return "redefinition of `%#D'";
4574       return 0;
4575     }
4576   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4577     {
4578       /* Objects declared at top level:  */
4579       /* If at least one is a reference, it's ok.  */
4580       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4581         return 0;
4582       /* Reject two definitions.  */
4583       return "redefinition of `%#D'";
4584     }
4585   else
4586     {
4587       /* Objects declared with block scope:  */
4588       /* Reject two definitions, and reject a definition
4589          together with an external reference.  */
4590       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4591         return "redeclaration of `%#D'";
4592       return 0;
4593     }
4594 }
4595 \f
4596 /* Create a new label, named ID.  */
4597
4598 static tree
4599 make_label_decl (id, local_p)
4600      tree id;
4601      int local_p;
4602 {
4603   tree decl;
4604
4605   decl = build_decl (LABEL_DECL, id, void_type_node);
4606   if (expanding_p)
4607     /* Make sure every label has an rtx.  */
4608     label_rtx (decl);
4609
4610   DECL_CONTEXT (decl) = current_function_decl;
4611   DECL_MODE (decl) = VOIDmode;
4612   C_DECLARED_LABEL_FLAG (decl) = local_p;
4613
4614   /* Say where one reference is to the label, for the sake of the
4615      error if it is not defined.  */
4616   DECL_SOURCE_LINE (decl) = lineno;
4617   DECL_SOURCE_FILE (decl) = input_filename;
4618
4619   /* Record the fact that this identifier is bound to this label.  */
4620   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4621
4622   /* Record this label on the list of used labels so that we can check
4623      at the end of the function to see whether or not the label was
4624      actually defined.  */
4625   if ((named_label_uses == NULL || named_label_uses->label_decl != decl)
4626       && (named_label_uses == NULL
4627           || named_label_uses->names_in_scope != current_binding_level->names
4628           || named_label_uses->label_decl != decl))
4629     {
4630       struct named_label_list *new_ent;
4631       new_ent
4632         = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4633       new_ent->label_decl = decl;
4634       new_ent->names_in_scope = current_binding_level->names;
4635       new_ent->binding_level = current_binding_level;
4636       new_ent->lineno_o_goto = lineno;
4637       new_ent->filename_o_goto = input_filename;
4638       new_ent->next = named_label_uses;
4639       named_label_uses = new_ent;
4640     }
4641
4642   return decl;
4643 }
4644
4645 /* Look for a label named ID in the current function.  If one cannot
4646    be found, create one.  (We keep track of used, but undefined,
4647    labels, and complain about them at the end of a function.)  */
4648
4649 tree
4650 lookup_label (id)
4651      tree id;
4652 {
4653   tree decl;
4654
4655   /* You can't use labels at global scope.  */
4656   if (current_function_decl == NULL_TREE)
4657     {
4658       error ("label `%s' referenced outside of any function",
4659              IDENTIFIER_POINTER (id));
4660       return NULL_TREE;
4661     }
4662
4663   /* See if we've already got this label.  */
4664   decl = IDENTIFIER_LABEL_VALUE (id);
4665   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4666     return decl;
4667
4668   /* Record this label on the list of labels used in this function.
4669      We do this before calling make_label_decl so that we get the
4670      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4671   named_labels = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4672                             named_labels);
4673   /* We need a new label.  */
4674   decl = make_label_decl (id, /*local_p=*/0);
4675   /* Now fill in the information we didn't have before.  */
4676   TREE_VALUE (named_labels) = decl;
4677
4678   return decl;
4679 }
4680
4681 /* Declare a local label named ID.  */
4682
4683 tree
4684 declare_local_label (id)
4685      tree id;
4686 {
4687   tree decl;
4688
4689   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4690      this scope we can restore the old value of
4691      IDENTIFIER_TYPE_VALUE.  */
4692   current_binding_level->shadowed_labels
4693     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4694                  current_binding_level->shadowed_labels);
4695   /* Look for the label.  */
4696   decl = make_label_decl (id, /*local_p=*/1);
4697   /* Now fill in the information we didn't have before.  */
4698   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4699
4700   return decl;
4701 }
4702
4703 /* Define a label, specifying the location in the source file.
4704    Return the LABEL_DECL node for the label, if the definition is valid.
4705    Otherwise return 0.  */
4706
4707 tree
4708 define_label (filename, line, name)
4709      char *filename;
4710      int line;
4711      tree name;
4712 {
4713   tree decl = lookup_label (name);
4714
4715   /* After labels, make any new cleanups go into their
4716      own new (temporary) binding contour.  */
4717   current_binding_level->more_cleanups_ok = 0;
4718
4719   if (name == get_identifier ("wchar_t"))
4720     cp_pedwarn ("label named wchar_t");
4721
4722   if (DECL_INITIAL (decl) != NULL_TREE)
4723     {
4724       cp_error ("duplicate label `%D'", decl);
4725       return 0;
4726     }
4727   else
4728     {
4729       struct named_label_list *uses, *prev;
4730       int identified = 0;
4731       int saw_eh = 0;
4732
4733       /* Mark label as having been defined.  */
4734       DECL_INITIAL (decl) = error_mark_node;
4735       /* Say where in the source.  */
4736       DECL_SOURCE_FILE (decl) = filename;
4737       DECL_SOURCE_LINE (decl) = line;
4738
4739       prev = NULL;
4740       uses = named_label_uses;
4741       while (uses != NULL)
4742         if (uses->label_decl == decl)
4743           {
4744             struct binding_level *b = current_binding_level;
4745             while (b)
4746               {
4747                 tree new_decls = b->names;
4748                 tree old_decls = (b == uses->binding_level)
4749                                   ? uses->names_in_scope : NULL_TREE;
4750                 while (new_decls != old_decls)
4751                   {
4752                     if (TREE_CODE (new_decls) == VAR_DECL
4753                         /* Don't complain about crossing initialization
4754                            of internal entities.  They can't be accessed,
4755                            and they should be cleaned up
4756                            by the time we get to the label.  */
4757                         && ! DECL_ARTIFICIAL (new_decls)
4758                         && !(DECL_INITIAL (new_decls) == NULL_TREE
4759                              && pod_type_p (TREE_TYPE (new_decls))))
4760                       {
4761                         /* This is really only important if we're crossing
4762                            an initialization.  The POD stuff is just
4763                            pedantry; why should it matter if the class
4764                            contains a field of pointer to member type?  */
4765                         int problem = (DECL_INITIAL (new_decls)
4766                                        || (TYPE_NEEDS_CONSTRUCTING
4767                                            (TREE_TYPE (new_decls))));
4768
4769                         if (! identified)
4770                           {
4771                             if (problem)
4772                               {
4773                                 cp_error ("jump to label `%D'", decl);
4774                                 error_with_file_and_line
4775                                   (uses->filename_o_goto,
4776                                    uses->lineno_o_goto, "  from here");
4777                               }
4778                             else
4779                               {
4780                                 cp_pedwarn ("jump to label `%D'", decl);
4781                                 pedwarn_with_file_and_line
4782                                   (uses->filename_o_goto,
4783                                    uses->lineno_o_goto, "  from here");
4784                               }
4785                             identified = 1;
4786                           }
4787
4788                         if (problem)
4789                           cp_error_at ("  crosses initialization of `%#D'",
4790                                        new_decls);
4791                         else
4792                           cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4793                                          new_decls);
4794                       }
4795                     new_decls = TREE_CHAIN (new_decls);
4796                   }
4797                 if (b == uses->binding_level)
4798                   break;
4799                 if (b->eh_region && ! saw_eh)
4800                   {
4801                     if (! identified)
4802                       {
4803                         cp_error ("jump to label `%D'", decl);
4804                         error_with_file_and_line
4805                           (uses->filename_o_goto,
4806                            uses->lineno_o_goto, "  from here");
4807                         identified = 1;
4808                       }
4809                     error ("  enters exception handling block");
4810                     saw_eh = 1;
4811                   }
4812                 b = b->level_chain;
4813               }
4814
4815             if (prev != NULL)
4816               prev->next = uses->next;
4817             else
4818               named_label_uses = uses->next;
4819
4820             uses = uses->next;
4821           }
4822         else
4823           {
4824             prev = uses;
4825             uses = uses->next;
4826           }
4827       current_function_return_value = NULL_TREE;
4828       return decl;
4829     }
4830 }
4831
4832 struct cp_switch
4833 {
4834   struct binding_level *level;
4835   struct cp_switch *next;
4836 };
4837
4838 static struct cp_switch *switch_stack;
4839
4840 void
4841 push_switch ()
4842 {
4843   struct cp_switch *p
4844     = (struct cp_switch *) oballoc (sizeof (struct cp_switch));
4845   p->level = current_binding_level;
4846   p->next = switch_stack;
4847   switch_stack = p;
4848 }
4849
4850 void
4851 pop_switch ()
4852 {
4853   switch_stack = switch_stack->next;
4854 }
4855
4856 /* Note that we've seen a definition of a case label, and complain if this
4857    is a bad place for one.  */
4858
4859 void
4860 define_case_label ()
4861 {
4862   tree cleanup = last_cleanup_this_contour ();
4863   struct binding_level *b = current_binding_level;
4864   int identified = 0;
4865
4866   if (! switch_stack)
4867     /* Don't crash; we'll complain in do_case.  */
4868     return;
4869
4870   if (cleanup)
4871     {
4872       static int explained = 0;
4873       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4874       warning ("where case label appears here");
4875       if (!explained)
4876         {
4877           warning ("(enclose actions of previous case statements requiring");
4878           warning ("destructors in their own binding contours.)");
4879           explained = 1;
4880         }
4881     }
4882
4883   for (; b && b != switch_stack->level; b = b->level_chain)
4884     {
4885       tree new_decls = b->names;
4886       for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4887         {
4888           if (TREE_CODE (new_decls) == VAR_DECL
4889               /* Don't complain about crossing initialization
4890                  of internal entities.  They can't be accessed,
4891                  and they should be cleaned up
4892                  by the time we get to the label.  */
4893               && ! DECL_ARTIFICIAL (new_decls)
4894               && ((DECL_INITIAL (new_decls) != NULL_TREE
4895                    && DECL_INITIAL (new_decls) != error_mark_node)
4896                   || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4897             {
4898               if (! identified)
4899                 error ("jump to case label");
4900               identified = 1;
4901               cp_error_at ("  crosses initialization of `%#D'",
4902                            new_decls);
4903             }
4904         }
4905     }
4906
4907   /* After labels, make any new cleanups go into their
4908      own new (temporary) binding contour.  */
4909
4910   current_binding_level->more_cleanups_ok = 0;
4911   current_function_return_value = NULL_TREE;
4912 }
4913 \f
4914 /* Return the list of declarations of the current level.
4915    Note that this list is in reverse order unless/until
4916    you nreverse it; and when you do nreverse it, you must
4917    store the result back using `storedecls' or you will lose.  */
4918
4919 tree
4920 getdecls ()
4921 {
4922   return current_binding_level->names;
4923 }
4924
4925 /* Return the list of type-tags (for structs, etc) of the current level.  */
4926
4927 tree
4928 gettags ()
4929 {
4930   return current_binding_level->tags;
4931 }
4932
4933 /* Store the list of declarations of the current level.
4934    This is done for the parameter declarations of a function being defined,
4935    after they are modified in the light of any missing parameters.  */
4936
4937 static void
4938 storedecls (decls)
4939      tree decls;
4940 {
4941   current_binding_level->names = decls;
4942 }
4943
4944 /* Similarly, store the list of tags of the current level.  */
4945
4946 void
4947 storetags (tags)
4948      tree tags;
4949 {
4950   current_binding_level->tags = tags;
4951 }
4952 \f
4953 /* Given NAME, an IDENTIFIER_NODE,
4954    return the structure (or union or enum) definition for that name.
4955    Searches binding levels from BINDING_LEVEL up to the global level.
4956    If THISLEVEL_ONLY is nonzero, searches only the specified context
4957    (but skips any tag-transparent contexts to find one that is
4958    meaningful for tags).
4959    FORM says which kind of type the caller wants;
4960    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4961    If the wrong kind of type is found, and it's not a template, an error is
4962    reported.  */
4963
4964 static tree
4965 lookup_tag (form, name, binding_level, thislevel_only)
4966      enum tree_code form;
4967      tree name;
4968      struct binding_level *binding_level;
4969      int thislevel_only;
4970 {
4971   register struct binding_level *level;
4972   /* Non-zero if, we should look past a pseudo-global level, even if
4973      THISLEVEL_ONLY.  */
4974   int allow_pseudo_global = 1;
4975
4976   for (level = binding_level; level; level = level->level_chain)
4977     {
4978       register tree tail;
4979       if (ANON_AGGRNAME_P (name))
4980         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4981           {
4982             /* There's no need for error checking here, because
4983                anon names are unique throughout the compilation.  */
4984             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
4985               return TREE_VALUE (tail);
4986           }
4987       else if (level->namespace_p)
4988         /* Do namespace lookup. */
4989         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
4990           {
4991             tree old = binding_for_name (name, tail);
4992
4993             /* If we just skipped past a pseudo global level, even
4994                though THISLEVEL_ONLY, and we find a template class
4995                declaration, then we use the _TYPE node for the
4996                template.  See the example below.  */
4997             if (thislevel_only && !allow_pseudo_global
4998                 && old && BINDING_VALUE (old)
4999                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5000               old = TREE_TYPE (BINDING_VALUE (old));
5001             else
5002               old = BINDING_TYPE (old);
5003
5004             /* If it has an original type, it is a typedef, and we
5005                should not return it.  */
5006             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5007               old = NULL_TREE;
5008             if (old && TREE_CODE (old) != form
5009                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5010               {
5011                 cp_error ("`%#D' redeclared as %C", old, form);
5012                 return NULL_TREE;
5013               }
5014             if (old)
5015               return old;
5016             if (thislevel_only || tail == global_namespace)
5017               return NULL_TREE;
5018           }
5019       else
5020         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5021           {
5022             if (TREE_PURPOSE (tail) == name)
5023               {
5024                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5025                 /* Should tighten this up; it'll probably permit
5026                    UNION_TYPE and a struct template, for example.  */
5027                 if (code != form
5028                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5029                   {
5030                     /* Definition isn't the kind we were looking for.  */
5031                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5032                               form);
5033                     return NULL_TREE;
5034                   }
5035                 return TREE_VALUE (tail);
5036               }
5037           }
5038       if (thislevel_only && ! level->tag_transparent)
5039         {
5040           if (level->pseudo_global && allow_pseudo_global)
5041             {
5042               /* We must deal with cases like this:
5043
5044                    template <class T> struct S;
5045                    template <class T> struct S {};
5046
5047                  When looking up `S', for the second declaration, we
5048                  would like to find the first declaration.  But, we
5049                  are in the pseudo-global level created for the
5050                  template parameters, rather than the (surrounding)
5051                  namespace level.  Thus, we keep going one more level,
5052                  even though THISLEVEL_ONLY is non-zero.  */
5053               allow_pseudo_global = 0;
5054               continue;
5055             }
5056           else
5057             return NULL_TREE;
5058         }
5059     }
5060   return NULL_TREE;
5061 }
5062
5063 #if 0
5064 void
5065 set_current_level_tags_transparency (tags_transparent)
5066      int tags_transparent;
5067 {
5068   current_binding_level->tag_transparent = tags_transparent;
5069 }
5070 #endif
5071
5072 /* Given a type, find the tag that was defined for it and return the tag name.
5073    Otherwise return 0.  However, the value can never be 0
5074    in the cases in which this is used.
5075
5076    C++: If NAME is non-zero, this is the new name to install.  This is
5077    done when replacing anonymous tags with real tag names.  */
5078
5079 static tree
5080 lookup_tag_reverse (type, name)
5081      tree type;
5082      tree name;
5083 {
5084   register struct binding_level *level;
5085
5086   for (level = current_binding_level; level; level = level->level_chain)
5087     {
5088       register tree tail;
5089       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5090         {
5091           if (TREE_VALUE (tail) == type)
5092             {
5093               if (name)
5094                 TREE_PURPOSE (tail) = name;
5095               return TREE_PURPOSE (tail);
5096             }
5097         }
5098     }
5099   return NULL_TREE;
5100 }
5101 \f
5102 /* Look up NAME in the NAMESPACE.  */
5103
5104 tree
5105 lookup_namespace_name (namespace, name)
5106      tree namespace, name;
5107 {
5108   tree val;
5109   tree template_id = NULL_TREE;
5110
5111   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5112
5113   if (TREE_CODE (name) == NAMESPACE_DECL)
5114     /* This happens for A::B<int> when B is a namespace. */
5115     return name;
5116   else if (TREE_CODE (name) == TEMPLATE_DECL)
5117     {
5118       /* This happens for A::B where B is a template, and there are no
5119          template arguments.  */
5120       cp_error ("invalid use of `%D'", name);
5121       return error_mark_node;
5122     }
5123
5124   namespace = ORIGINAL_NAMESPACE (namespace);
5125
5126   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5127     {
5128       template_id = name;
5129       name = TREE_OPERAND (name, 0);
5130       if (TREE_CODE (name) == OVERLOAD)
5131         name = DECL_NAME (OVL_CURRENT (name));
5132       else if (TREE_CODE_CLASS (TREE_CODE (name)) == 'd')
5133         name = DECL_NAME (name);
5134     }
5135
5136   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5137
5138   val = make_node (CPLUS_BINDING);
5139   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5140     return error_mark_node;
5141
5142   if (BINDING_VALUE (val))
5143     {
5144       val = BINDING_VALUE (val);
5145
5146       if (template_id)
5147         {
5148           if (DECL_CLASS_TEMPLATE_P (val))
5149             val = lookup_template_class (val,
5150                                          TREE_OPERAND (template_id, 1),
5151                                          /*in_decl=*/NULL_TREE,
5152                                          /*context=*/NULL_TREE,
5153                                          /*entering_scope=*/0);
5154           else if (DECL_FUNCTION_TEMPLATE_P (val)
5155                    || TREE_CODE (val) == OVERLOAD)
5156             val = lookup_template_function (val,
5157                                             TREE_OPERAND (template_id, 1));
5158           else
5159             {
5160               cp_error ("`%D::%D' is not a template",
5161                         namespace, name);
5162               return error_mark_node;
5163             }
5164         }
5165
5166       /* If we have a single function from a using decl, pull it out.  */
5167       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5168         val = OVL_FUNCTION (val);
5169       return val;
5170     }
5171
5172   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5173   return error_mark_node;
5174 }
5175
5176 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5177
5178 static unsigned long
5179 typename_hash (k)
5180      hash_table_key k;
5181 {
5182   unsigned long hash;
5183   tree t;
5184
5185   t = (tree) k;
5186   hash = (((unsigned long) TYPE_CONTEXT (t))
5187           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5188
5189   return hash;
5190 }
5191
5192 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5193
5194 static boolean
5195 typename_compare (k1, k2)
5196      hash_table_key k1;
5197      hash_table_key k2;
5198 {
5199   tree t1;
5200   tree t2;
5201   tree d1;
5202   tree d2;
5203
5204   t1 = (tree) k1;
5205   t2 = (tree) k2;
5206   d1 = TYPE_NAME (t1);
5207   d2 = TYPE_NAME (t2);
5208
5209   return (DECL_NAME (d1) == DECL_NAME (d2)
5210           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5211           && ((TREE_TYPE (t1) != NULL_TREE)
5212               == (TREE_TYPE (t2) != NULL_TREE))
5213           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5214           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5215 }
5216
5217 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5218    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5219    is non-NULL, this type is being created by the implicit typename
5220    extension, and BASE_TYPE is a type named `t' in some base class of
5221    `T' which depends on template parameters.
5222
5223    Returns the new TYPENAME_TYPE.  */
5224
5225 tree
5226 build_typename_type (context, name, fullname, base_type)
5227      tree context;
5228      tree name;
5229      tree fullname;
5230      tree base_type;
5231 {
5232   tree t;
5233   tree d;
5234   struct hash_entry* e;
5235
5236   static struct hash_table ht;
5237
5238   if (!ht.table)
5239     {
5240       static struct hash_table *h = &ht;
5241       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5242                             &typename_compare))
5243         fatal ("virtual memory exhausted");
5244       ggc_add_tree_hash_table_root (&h, 1);
5245     }
5246
5247   /* Build the TYPENAME_TYPE.  */
5248   t = make_aggr_type (TYPENAME_TYPE);
5249   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5250   TYPENAME_TYPE_FULLNAME (t) = fullname;
5251   TREE_TYPE (t) = base_type;
5252
5253   /* Build the corresponding TYPE_DECL.  */
5254   d = build_decl (TYPE_DECL, name, t);
5255   TYPE_NAME (TREE_TYPE (d)) = d;
5256   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5257   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5258   DECL_ARTIFICIAL (d) = 1;
5259
5260   /* See if we already have this type.  */
5261   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5262   if (e)
5263     t = (tree) e->key;
5264   else
5265     /* Insert the type into the table.  */
5266     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5267
5268   return t;
5269 }
5270
5271 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5272    unless an error occurs, in which case error_mark_node is returned.
5273    If COMPLAIN zero, don't complain about any errors that occur.  */
5274
5275 tree
5276 make_typename_type (context, name, complain)
5277      tree context, name;
5278      int complain;
5279 {
5280   tree fullname;
5281
5282   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
5283     {
5284       if (!(TYPE_LANG_SPECIFIC (name)
5285             && (CLASSTYPE_IS_TEMPLATE (name)
5286                 || CLASSTYPE_USE_TEMPLATE (name))))
5287         name = TYPE_IDENTIFIER (name);
5288       else
5289         /* Create a TEMPLATE_ID_EXPR for the type.  */
5290         name = build_nt (TEMPLATE_ID_EXPR,
5291                          CLASSTYPE_TI_TEMPLATE (name),
5292                          CLASSTYPE_TI_ARGS (name));
5293     }
5294   else if (TREE_CODE (name) == TYPE_DECL)
5295     name = DECL_NAME (name);
5296
5297   fullname = name;
5298
5299   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5300     {
5301       name = TREE_OPERAND (name, 0);
5302       if (TREE_CODE (name) == TEMPLATE_DECL)
5303         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5304     }
5305   if (TREE_CODE (name) != IDENTIFIER_NODE)
5306     my_friendly_abort (2000);
5307
5308   if (TREE_CODE (context) == NAMESPACE_DECL)
5309     {
5310       /* We can get here from typename_sub0 in the explicit_template_type
5311          expansion.  Just fail.  */
5312       if (complain)
5313         cp_error ("no class template named `%#T' in `%#T'",
5314                   name, context);
5315       return error_mark_node;
5316     }
5317
5318   if (! uses_template_parms (context)
5319       || currently_open_class (context))
5320     {
5321       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5322         {
5323           tree tmpl = NULL_TREE;
5324           if (IS_AGGR_TYPE (context))
5325             tmpl = lookup_field (context, name, 0, 0);
5326           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5327             {
5328               if (complain)
5329                 cp_error ("no class template named `%#T' in `%#T'",
5330                           name, context);
5331               return error_mark_node;
5332             }
5333
5334           return lookup_template_class (tmpl,
5335                                         TREE_OPERAND (fullname, 1),
5336                                         NULL_TREE, context,
5337                                         /*entering_scope=*/0);
5338         }
5339       else
5340         {
5341           tree t;
5342
5343           if (!IS_AGGR_TYPE (context))
5344             {
5345               if (complain)
5346                 cp_error ("no type named `%#T' in `%#T'", name, context);
5347               return error_mark_node;
5348             }
5349
5350           t = lookup_field (context, name, 0, 1);
5351           if (t)
5352             return TREE_TYPE (t);
5353         }
5354     }
5355
5356   /* If the CONTEXT is not a template type, then either the field is
5357      there now or its never going to be.  */
5358   if (!uses_template_parms (context))
5359     {
5360       if (complain)
5361         cp_error ("no type named `%#T' in `%#T'", name, context);
5362       return error_mark_node;
5363     }
5364
5365
5366   return build_typename_type (context, name, fullname,  NULL_TREE);
5367 }
5368
5369 /* Select the right _DECL from multiple choices. */
5370
5371 static tree
5372 select_decl (binding, flags)
5373      tree binding;
5374      int flags;
5375 {
5376   tree val;
5377   val = BINDING_VALUE (binding);
5378   if (LOOKUP_NAMESPACES_ONLY (flags))
5379     {
5380       /* We are not interested in types. */
5381       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5382         return val;
5383       return NULL_TREE;
5384     }
5385
5386   /* If we could have a type and
5387      we have nothing or we need a type and have none.  */
5388   if (BINDING_TYPE (binding)
5389       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5390                    && TREE_CODE (val) != TYPE_DECL)))
5391     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5392   /* Don't return non-types if we really prefer types. */
5393   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5394            && (TREE_CODE (val) != TEMPLATE_DECL
5395                || !DECL_CLASS_TEMPLATE_P (val)))
5396     val = NULL_TREE;
5397
5398   return val;
5399 }
5400
5401 /* Unscoped lookup of a global: iterate over current namespaces,
5402    considering using-directives.  If SPACESP is non-NULL, store a list
5403    of the namespaces we've considered in it.  */
5404
5405 tree
5406 unqualified_namespace_lookup (name, flags, spacesp)
5407      tree name;
5408      int flags;
5409      tree *spacesp;
5410 {
5411   tree b = make_node (CPLUS_BINDING);
5412   tree initial = current_decl_namespace();
5413   tree scope = initial;
5414   tree siter;
5415   struct binding_level *level;
5416   tree val = NULL_TREE;
5417
5418   if (spacesp)
5419     *spacesp = NULL_TREE;
5420
5421   for (; !val; scope = CP_DECL_CONTEXT (scope))
5422     {
5423       if (spacesp)
5424         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5425       val = binding_for_name (name, scope);
5426
5427       /* Initialize binding for this context. */
5428       BINDING_VALUE (b) = BINDING_VALUE (val);
5429       BINDING_TYPE (b) = BINDING_TYPE (val);
5430
5431       /* Add all _DECLs seen through local using-directives. */
5432       for (level = current_binding_level;
5433            !level->namespace_p;
5434            level = level->level_chain)
5435         if (!lookup_using_namespace (name, b, level->using_directives,
5436                                      scope, flags, spacesp))
5437           /* Give up because of error. */
5438           return error_mark_node;
5439
5440       /* Add all _DECLs seen through global using-directives. */
5441       /* XXX local and global using lists should work equally. */
5442       siter = initial;
5443       while (1)
5444         {
5445           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5446                                        scope, flags, spacesp))
5447             /* Give up because of error. */
5448             return error_mark_node;
5449           if (siter == scope) break;
5450           siter = CP_DECL_CONTEXT (siter);
5451         }
5452
5453       val = select_decl (b, flags);
5454       if (scope == global_namespace)
5455         break;
5456     }
5457   return val;
5458 }
5459
5460 /* Combine prefer_type and namespaces_only into flags.  */
5461
5462 static int
5463 lookup_flags (prefer_type, namespaces_only)
5464   int prefer_type, namespaces_only;
5465 {
5466   if (namespaces_only)
5467     return LOOKUP_PREFER_NAMESPACES;
5468   if (prefer_type > 1)
5469     return LOOKUP_PREFER_TYPES;
5470   if (prefer_type > 0)
5471     return LOOKUP_PREFER_BOTH;
5472   return 0;
5473 }
5474
5475 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5476    ignore it or not.  Subroutine of lookup_name_real.  */
5477
5478 static tree
5479 qualify_lookup (val, flags)
5480      tree val;
5481      int flags;
5482 {
5483   if (val == NULL_TREE)
5484     return val;
5485   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5486     return val;
5487   if ((flags & LOOKUP_PREFER_TYPES)
5488       && (TREE_CODE (val) == TYPE_DECL
5489           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5490               && DECL_CLASS_TEMPLATE_P (val))))
5491     return val;
5492   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5493     return NULL_TREE;
5494   return val;
5495 }
5496
5497 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5498    that.  */
5499
5500 static void
5501 warn_about_implicit_typename_lookup (typename, binding)
5502      tree typename;
5503      tree binding;
5504 {
5505   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5506   tree name = DECL_NAME (typename);
5507
5508   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5509          && CLASSTYPE_TEMPLATE_INFO (subtype)
5510          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5511       && ! (TREE_CODE (binding) == TYPE_DECL
5512             && same_type_p (TREE_TYPE (binding), subtype)))
5513     {
5514       cp_warning ("lookup of `%D' finds `%#D'",
5515                   name, binding);
5516       cp_warning ("  instead of `%D' from dependent base class",
5517                   typename);
5518       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5519                   constructor_name (current_class_type), name);
5520     }
5521 }
5522
5523 /* Look up NAME in the current binding level and its superiors in the
5524    namespace of variables, functions and typedefs.  Return a ..._DECL
5525    node of some kind representing its definition if there is only one
5526    such declaration, or return a TREE_LIST with all the overloaded
5527    definitions if there are many, or return 0 if it is undefined.
5528
5529    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5530    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5531    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5532    Otherwise we prefer non-TYPE_DECLs.
5533
5534    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5535    using IDENTIFIER_CLASS_VALUE.  */
5536
5537 static tree
5538 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5539      tree name;
5540      int prefer_type, nonclass, namespaces_only;
5541 {
5542   tree t;
5543   tree val = NULL_TREE;
5544   int yylex = 0;
5545   tree from_obj = NULL_TREE;
5546   int flags;
5547   int val_is_implicit_typename = 0;
5548
5549   /* Hack: copy flag set by parser, if set. */
5550   if (only_namespace_names)
5551     namespaces_only = 1;
5552
5553   if (prefer_type == -2)
5554     {
5555       extern int looking_for_typename;
5556       tree type = NULL_TREE;
5557
5558       yylex = 1;
5559       prefer_type = looking_for_typename;
5560
5561       flags = lookup_flags (prefer_type, namespaces_only);
5562       /* If the next thing is '<', class templates are types. */
5563       if (looking_for_template)
5564         flags |= LOOKUP_TEMPLATES_EXPECTED;
5565
5566       /* std:: becomes :: for now.  */
5567       if (got_scope == std_node)
5568         got_scope = void_type_node;
5569
5570       if (got_scope)
5571         type = got_scope;
5572       else if (got_object != error_mark_node)
5573         type = got_object;
5574
5575       if (type)
5576         {
5577           if (type == error_mark_node)
5578             return error_mark_node;
5579           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5580             type = TREE_TYPE (type);
5581
5582           if (TYPE_P (type))
5583             type = complete_type (type);
5584
5585           if (TREE_CODE (type) == VOID_TYPE)
5586             type = global_namespace;
5587           if (TREE_CODE (type) == NAMESPACE_DECL)
5588             {
5589               val = make_node (CPLUS_BINDING);
5590               flags |= LOOKUP_COMPLAIN;
5591               if (!qualified_lookup_using_namespace (name, type, val, flags))
5592                 return NULL_TREE;
5593               val = select_decl (val, flags);
5594             }
5595           else if (! IS_AGGR_TYPE (type)
5596                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5597                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5598                    || TREE_CODE (type) == TYPENAME_TYPE)
5599             /* Someone else will give an error about this if needed.  */
5600             val = NULL_TREE;
5601           else if (type == current_class_type)
5602             val = IDENTIFIER_CLASS_VALUE (name);
5603           else
5604             {
5605               val = lookup_member (type, name, 0, prefer_type);
5606               type_access_control (type, val);
5607             }
5608         }
5609       else
5610         val = NULL_TREE;
5611
5612       if (got_scope)
5613         goto done;
5614       else if (got_object && val)
5615         from_obj = val;
5616     }
5617   else
5618     {
5619       flags = lookup_flags (prefer_type, namespaces_only);
5620       /* If we're not parsing, we need to complain. */
5621       flags |= LOOKUP_COMPLAIN;
5622     }
5623
5624   /* First, look in non-namespace scopes.  */
5625
5626   if (current_class_type == NULL_TREE)
5627     nonclass = 1;
5628
5629   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5630     {
5631       tree binding;
5632
5633       if (!LOCAL_BINDING_P (t) && nonclass)
5634         /* We're not looking for class-scoped bindings, so keep going.  */
5635         continue;
5636
5637       /* If this is the kind of thing we're looking for, we're done.  */
5638       if (qualify_lookup (BINDING_VALUE (t), flags))
5639         binding = BINDING_VALUE (t);
5640       else if ((flags & LOOKUP_PREFER_TYPES)
5641                && qualify_lookup (BINDING_TYPE (t), flags))
5642         binding = BINDING_TYPE (t);
5643       else
5644         binding = NULL_TREE;
5645
5646       /* Handle access control on types from enclosing or base classes.  */
5647       if (binding && ! yylex
5648           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5649         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5650
5651       if (binding
5652           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5653         {
5654           if (val_is_implicit_typename && !yylex)
5655             warn_about_implicit_typename_lookup (val, binding);
5656           val = binding;
5657           val_is_implicit_typename
5658             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5659           if (!val_is_implicit_typename)
5660             break;
5661         }
5662     }
5663
5664   /* Now lookup in namespace scopes.  */
5665   if (!val || val_is_implicit_typename)
5666     {
5667       t = unqualified_namespace_lookup (name, flags, 0);
5668       if (t)
5669         {
5670           if (val_is_implicit_typename && !yylex)
5671             warn_about_implicit_typename_lookup (val, t);
5672           val = t;
5673         }
5674     }
5675
5676  done:
5677   if (val)
5678     {
5679       /* This should only warn about types used in qualified-ids.  */
5680       if (from_obj && from_obj != val)
5681         {
5682           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5683               && TREE_CODE (val) == TYPE_DECL
5684               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5685             {
5686               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5687                           name, got_object, TREE_TYPE (from_obj));
5688               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5689                           TREE_TYPE (val));
5690             }
5691
5692           /* We don't change val to from_obj if got_object depends on
5693              template parms because that breaks implicit typename for
5694              destructor calls.  */
5695           if (! uses_template_parms (got_object))
5696             val = from_obj;
5697         }
5698
5699       /* If we have a single function from a using decl, pull it out.  */
5700       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5701         val = OVL_FUNCTION (val);
5702     }
5703   else if (from_obj)
5704     val = from_obj;
5705
5706   return val;
5707 }
5708
5709 tree
5710 lookup_name_nonclass (name)
5711      tree name;
5712 {
5713   return lookup_name_real (name, 0, 1, 0);
5714 }
5715
5716 tree
5717 lookup_function_nonclass (name, args)
5718      tree name;
5719      tree args;
5720 {
5721   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5722 }
5723
5724 tree
5725 lookup_name_namespace_only (name)
5726      tree name;
5727 {
5728   /* type-or-namespace, nonclass, namespace_only */
5729   return lookup_name_real (name, 1, 1, 1);
5730 }
5731
5732 tree
5733 lookup_name (name, prefer_type)
5734      tree name;
5735      int prefer_type;
5736 {
5737   return lookup_name_real (name, prefer_type, 0, 0);
5738 }
5739
5740 /* Similar to `lookup_name' but look only in the innermost non-class
5741    binding level.  */
5742
5743 tree
5744 lookup_name_current_level (name)
5745      tree name;
5746 {
5747   struct binding_level *b;
5748   tree t = NULL_TREE;
5749
5750   b = current_binding_level;
5751   while (b->parm_flag == 2)
5752     b = b->level_chain;
5753
5754   if (b->namespace_p)
5755     {
5756       t = IDENTIFIER_NAMESPACE_VALUE (name);
5757
5758       /* extern "C" function() */
5759       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5760         t = TREE_VALUE (t);
5761     }
5762   else if (IDENTIFIER_BINDING (name)
5763            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
5764     {
5765       while (1)
5766         {
5767           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
5768             return IDENTIFIER_VALUE (name);
5769
5770           if (b->keep == 2)
5771             b = b->level_chain;
5772           else
5773             break;
5774         }
5775     }
5776
5777   return t;
5778 }
5779
5780 /* Like lookup_name_current_level, but for types.  */
5781
5782 tree
5783 lookup_type_current_level (name)
5784      tree name;
5785 {
5786   register tree t = NULL_TREE;
5787
5788   my_friendly_assert (! current_binding_level->namespace_p, 980716);
5789
5790   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5791       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5792     {
5793       struct binding_level *b = current_binding_level;
5794       while (1)
5795         {
5796           if (purpose_member (name, b->type_shadowed))
5797             return REAL_IDENTIFIER_TYPE_VALUE (name);
5798           if (b->keep == 2)
5799             b = b->level_chain;
5800           else
5801             break;
5802         }
5803     }
5804
5805   return t;
5806 }
5807
5808 void
5809 begin_only_namespace_names ()
5810 {
5811   only_namespace_names = 1;
5812 }
5813
5814 void
5815 end_only_namespace_names ()
5816 {
5817   only_namespace_names = 0;
5818 }
5819 \f
5820 /* Arrange for the user to get a source line number, even when the
5821    compiler is going down in flames, so that she at least has a
5822    chance of working around problems in the compiler.  We used to
5823    call error(), but that let the segmentation fault continue
5824    through; now, it's much more passive by asking them to send the
5825    maintainers mail about the problem.  */
5826
5827 static void
5828 signal_catch (sig)
5829      int sig ATTRIBUTE_UNUSED;
5830 {
5831   signal (SIGSEGV, SIG_DFL);
5832 #ifdef SIGIOT
5833   signal (SIGIOT, SIG_DFL);
5834 #endif
5835 #ifdef SIGILL
5836   signal (SIGILL, SIG_DFL);
5837 #endif
5838 #ifdef SIGABRT
5839   signal (SIGABRT, SIG_DFL);
5840 #endif
5841 #ifdef SIGBUS
5842   signal (SIGBUS, SIG_DFL);
5843 #endif
5844   my_friendly_abort (0);
5845 }
5846
5847 /* Push the declarations of builtin types into the namespace.
5848    RID_INDEX, if < RID_MAX is the index of the builtin type
5849    in the array RID_POINTERS.  NAME is the name used when looking
5850    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
5851
5852 static void
5853 record_builtin_type (rid_index, name, type)
5854      enum rid rid_index;
5855      const char *name;
5856      tree type;
5857 {
5858   tree rname = NULL_TREE, tname = NULL_TREE;
5859   tree tdecl = NULL_TREE;
5860
5861   if ((int) rid_index < (int) RID_MAX)
5862     rname = ridpointers[(int) rid_index];
5863   if (name)
5864     tname = get_identifier (name);
5865
5866   TYPE_BUILT_IN (type) = 1;
5867
5868   if (tname)
5869     {
5870       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5871       set_identifier_type_value (tname, NULL_TREE);
5872       if ((int) rid_index < (int) RID_MAX)
5873         /* Built-in types live in the global namespace. */
5874         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5875     }
5876   if (rname != NULL_TREE)
5877     {
5878       if (tname != NULL_TREE)
5879         {
5880           set_identifier_type_value (rname, NULL_TREE);
5881           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5882         }
5883       else
5884         {
5885           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5886           set_identifier_type_value (rname, NULL_TREE);
5887         }
5888     }
5889 }
5890
5891 /* Record one of the standard Java types.
5892  * Declare it as having the given NAME.
5893  * If SIZE > 0, it is the size of one of the integral types;
5894  * otherwise it is the negative of the size of one of the other types.  */
5895
5896 static tree
5897 record_builtin_java_type (name, size)
5898      const char *name;
5899      int size;
5900 {
5901   tree type, decl;
5902   if (size > 0)
5903     type = make_signed_type (size);
5904   else if (size > -32)
5905     { /* "__java_char" or ""__java_boolean". */
5906       type = make_unsigned_type (-size);
5907       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5908     }
5909   else
5910     { /* "__java_float" or ""__java_double". */
5911       type = make_node (REAL_TYPE);
5912       TYPE_PRECISION (type) = - size;
5913       layout_type (type);
5914     }
5915   record_builtin_type (RID_MAX, name, type);
5916   decl = TYPE_NAME (type);
5917
5918   /* Suppress generate debug symbol entries for these types,
5919      since for normal C++ they are just clutter.
5920      However, push_lang_context undoes this if extern "Java" is seen. */
5921   DECL_IGNORED_P (decl) = 1;
5922
5923   TYPE_FOR_JAVA (type) = 1;
5924   return type;
5925 }
5926
5927 /* Push a type into the namespace so that the back-ends ignore it. */
5928
5929 static void
5930 record_unknown_type (type, name)
5931      tree type;
5932      const char *name;
5933 {
5934   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
5935   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
5936   DECL_IGNORED_P (decl) = 1;
5937   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5938   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
5939   TYPE_ALIGN (type) = 1;
5940   TYPE_MODE (type) = TYPE_MODE (void_type_node);
5941 }
5942
5943 /* Create the predefined scalar types of C,
5944    and some nodes representing standard constants (0, 1, (void *)0).
5945    Initialize the global binding level.
5946    Make definitions for built-in primitive functions.  */
5947
5948 void
5949 init_decl_processing ()
5950 {
5951   tree fields[20];
5952   int wchar_type_size;
5953   tree array_domain_type;
5954
5955   /* Check to see that the user did not specify an invalid combination
5956      of command-line options.  */
5957   if (flag_new_abi && !flag_vtable_thunks)
5958     fatal ("the new ABI requires vtable thunks");
5959
5960   /* Have to make these distinct before we try using them.  */
5961   lang_name_cplusplus = get_identifier ("C++");
5962   lang_name_c = get_identifier ("C");
5963   lang_name_java = get_identifier ("Java");
5964
5965   /* Let the back-end now how to save and restore language-specific
5966      per-function globals.  */
5967   init_lang_status = &push_cp_function_context;
5968   free_lang_status = &pop_cp_function_context;
5969   mark_lang_status = &mark_cp_function_context;
5970
5971   cp_parse_init ();
5972   init_decl2 ();
5973   init_pt ();
5974
5975   /* Create the global variables.  */
5976   push_to_top_level ();
5977
5978   /* Enter the global namespace. */
5979   my_friendly_assert (global_namespace == NULL_TREE, 375);
5980   push_namespace (get_identifier ("::"));
5981   global_namespace = current_namespace;
5982   current_lang_name = NULL_TREE;
5983
5984   /* Adjust various flags based on command-line settings.  */
5985   if (flag_strict_prototype == 2)
5986     flag_strict_prototype = pedantic;
5987   if (! flag_permissive && ! pedantic)
5988     flag_pedantic_errors = 1;
5989   if (!flag_no_inline)
5990     flag_inline_trees = 1;
5991
5992   strict_prototypes_lang_c = flag_strict_prototype;
5993
5994   /* Initially, C.  */
5995   current_lang_name = lang_name_c;
5996
5997   current_function_decl = NULL_TREE;
5998   current_binding_level = NULL_BINDING_LEVEL;
5999   free_binding_level = NULL_BINDING_LEVEL;
6000
6001   /* Because most segmentation signals can be traced back into user
6002      code, catch them and at least give the user a chance of working
6003      around compiler bugs.  */
6004   signal (SIGSEGV, signal_catch);
6005
6006   /* We will also catch aborts in the back-end through signal_catch and
6007      give the user a chance to see where the error might be, and to defeat
6008      aborts in the back-end when there have been errors previously in their
6009      code.  */
6010 #ifdef SIGIOT
6011   signal (SIGIOT, signal_catch);
6012 #endif
6013 #ifdef SIGILL
6014   signal (SIGILL, signal_catch);
6015 #endif
6016 #ifdef SIGABRT
6017   signal (SIGABRT, signal_catch);
6018 #endif
6019 #ifdef SIGBUS
6020   signal (SIGBUS, signal_catch);
6021 #endif
6022
6023   build_common_tree_nodes (flag_signed_char);
6024
6025   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6026   TREE_TYPE (error_mark_list) = error_mark_node;
6027
6028   /* Make the binding_level structure for global names.  */
6029   pushlevel (0);
6030   global_binding_level = current_binding_level;
6031   /* The global level is the namespace level of ::.  */
6032   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6033   declare_namespace_level ();
6034
6035   this_identifier = get_identifier (THIS_NAME);
6036   in_charge_identifier = get_identifier (IN_CHARGE_NAME);
6037   ctor_identifier = get_identifier (CTOR_NAME);
6038   dtor_identifier = get_identifier (DTOR_NAME);
6039   pfn_identifier = get_identifier (VTABLE_PFN_NAME);
6040   index_identifier = get_identifier (VTABLE_INDEX_NAME);
6041   delta_identifier = get_identifier (VTABLE_DELTA_NAME);
6042   delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
6043   pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
6044
6045   /* Define `int' and `char' first so that dbx will output them first.  */
6046   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6047   record_builtin_type (RID_CHAR, "char", char_type_node);
6048
6049   /* `signed' is the same as `int' */
6050   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6051   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6052   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6053   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6054   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6055   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6056   record_builtin_type (RID_MAX, "long long unsigned int",
6057                        long_long_unsigned_type_node);
6058   record_builtin_type (RID_MAX, "long long unsigned",
6059                        long_long_unsigned_type_node);
6060   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6061   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6062   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6063
6064   ptrdiff_type_node
6065     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6066
6067   /* Define both `signed char' and `unsigned char'.  */
6068   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6069   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6070
6071   /* `unsigned long' is the standard type for sizeof.
6072      Note that stddef.h uses `unsigned long',
6073      and this must agree, even if long and int are the same size.  */
6074   set_sizetype
6075     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6076
6077   /* Create the widest literal types. */
6078   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6079   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6080                         widest_integer_literal_type_node));
6081
6082   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6083   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6084                         widest_unsigned_literal_type_node));
6085
6086   /* These are types that type_for_size and type_for_mode use.  */
6087   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6088   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6089   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6090   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6091 #if HOST_BITS_PER_WIDE_INT >= 64
6092   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6093 #endif
6094   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6095   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6096   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6097   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6098 #if HOST_BITS_PER_WIDE_INT >= 64
6099   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6100 #endif
6101
6102   build_common_tree_nodes_2 (flag_short_double);
6103
6104   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6105   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6106   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6107   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6108   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6109   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6110   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6111   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6112
6113   integer_two_node = build_int_2 (2, 0);
6114   TREE_TYPE (integer_two_node) = integer_type_node;
6115   integer_three_node = build_int_2 (3, 0);
6116   TREE_TYPE (integer_three_node) = integer_type_node;
6117
6118   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6119   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6120   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6121   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6122   TYPE_PRECISION (boolean_type_node) = 1;
6123   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6124   boolean_false_node = build_int_2 (0, 0);
6125   TREE_TYPE (boolean_false_node) = boolean_type_node;
6126   boolean_true_node = build_int_2 (1, 0);
6127   TREE_TYPE (boolean_true_node) = boolean_type_node;
6128
6129   signed_size_zero_node = build_int_2 (0, 0);  record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6130   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6131   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6132
6133   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6134                         complex_integer_type_node));
6135   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6136                         complex_float_type_node));
6137   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6138                         complex_double_type_node));
6139   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6140                         complex_long_double_type_node));
6141
6142   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6143
6144   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6145   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6146   TREE_PARMLIST (void_list_node) = 1;
6147
6148   /* Used for expressions that do nothing, but are not errors.  */
6149   void_zero_node = build_int_2 (0, 0);
6150   TREE_TYPE (void_zero_node) = void_type_node;
6151
6152   string_type_node = build_pointer_type (char_type_node);
6153   const_string_type_node
6154     = build_pointer_type (build_qualified_type (char_type_node,
6155                                                 TYPE_QUAL_CONST));
6156   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6157 #if 0
6158   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6159 #endif
6160
6161   /* Make a type to be the domain of a few array types
6162      whose domains don't really matter.
6163      200 is small enough that it always fits in size_t.  */
6164   array_domain_type = build_index_type (build_int_2 (200, 0));
6165
6166   /* Make a type for arrays of characters.
6167      With luck nothing will ever really depend on the length of this
6168      array type.  */
6169   char_array_type_node
6170     = build_array_type (char_type_node, array_domain_type);
6171   /* Likewise for arrays of ints.  */
6172   int_array_type_node
6173     = build_array_type (integer_type_node, array_domain_type);
6174
6175   if (flag_new_abi)
6176     delta_type_node = ptrdiff_type_node;
6177   else if (flag_huge_objects)
6178     delta_type_node = long_integer_type_node;
6179   else
6180     delta_type_node = short_integer_type_node;
6181
6182   if (flag_new_abi)
6183     vtable_index_type = ptrdiff_type_node;
6184   else
6185     vtable_index_type = delta_type_node;
6186
6187   default_function_type
6188     = build_function_type (integer_type_node, NULL_TREE);
6189
6190   ptr_type_node = build_pointer_type (void_type_node);
6191   const_ptr_type_node
6192     = build_pointer_type (build_qualified_type (void_type_node,
6193                                                 TYPE_QUAL_CONST));
6194   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6195   lang_type_promotes_to = convert_type_from_ellipsis;
6196
6197   void_ftype_ptr
6198     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6199
6200   /* C++ extensions */
6201
6202   unknown_type_node = make_node (UNKNOWN_TYPE);
6203   record_unknown_type (unknown_type_node, "unknown type");
6204
6205   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6206   TREE_TYPE (unknown_type_node) = unknown_type_node;
6207
6208   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6209
6210   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6211      result.  */
6212   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6213   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6214
6215   /* This is special for C++ so functions can be overloaded.  */
6216   wchar_type_node = get_identifier (flag_short_wchar
6217                                     ? "short unsigned int"
6218                                     : WCHAR_TYPE);
6219   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6220   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6221   signed_wchar_type_node = make_signed_type (wchar_type_size);
6222   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6223   wchar_type_node
6224     = TREE_UNSIGNED (wchar_type_node)
6225       ? unsigned_wchar_type_node
6226       : signed_wchar_type_node;
6227   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6228
6229   /* Artificial declaration of wchar_t -- can be bashed */
6230   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6231                                 wchar_type_node);
6232   pushdecl (wchar_decl_node);
6233
6234   /* This is for wide string constants.  */
6235   wchar_array_type_node
6236     = build_array_type (wchar_type_node, array_domain_type);
6237
6238   if (flag_vtable_thunks)
6239     {
6240       /* Make sure we get a unique function type, so we can give
6241          its pointer type a name.  (This wins for gdb.) */
6242       tree vfunc_type = make_node (FUNCTION_TYPE);
6243       TREE_TYPE (vfunc_type) = integer_type_node;
6244       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6245       layout_type (vfunc_type);
6246
6247       vtable_entry_type = build_pointer_type (vfunc_type);
6248     }
6249   else
6250     {
6251       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6252       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
6253                                    delta_type_node);
6254       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
6255                                    delta_type_node);
6256       fields[2] = build_lang_decl (FIELD_DECL, pfn_identifier,
6257                                    ptr_type_node);
6258       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6259                            double_type_node);
6260
6261       /* Make this part of an invisible union.  */
6262       fields[3] = copy_node (fields[2]);
6263       TREE_TYPE (fields[3]) = delta_type_node;
6264       DECL_NAME (fields[3]) = delta2_identifier;
6265       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6266       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6267       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6268       TREE_UNSIGNED (fields[3]) = 0;
6269       TREE_CHAIN (fields[2]) = fields[3];
6270       vtable_entry_type = build_qualified_type (vtable_entry_type,
6271                                                 TYPE_QUAL_CONST);
6272     }
6273   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6274
6275   vtbl_type_node
6276     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6277   layout_type (vtbl_type_node);
6278   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6279   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6280   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6281   layout_type (vtbl_ptr_type_node);
6282   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6283
6284   std_node = build_decl (NAMESPACE_DECL,
6285                          get_identifier (flag_honor_std ? "fake std":"std"),
6286                          void_type_node);
6287   pushdecl (std_node);
6288
6289   global_type_node = make_node (LANG_TYPE);
6290   record_unknown_type (global_type_node, "global type");
6291
6292   /* Now, C++.  */
6293   current_lang_name = lang_name_cplusplus;
6294
6295   {
6296     tree bad_alloc_type_node, newtype, deltype;
6297     if (flag_honor_std)
6298       push_namespace (get_identifier ("std"));
6299     bad_alloc_type_node = xref_tag
6300       (class_type_node, get_identifier ("bad_alloc"), 1);
6301     if (flag_honor_std)
6302       pop_namespace ();
6303     newtype = build_exception_variant
6304       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6305     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6306     push_cp_library_fn (ansi_opname[(int) NEW_EXPR], newtype);
6307     push_cp_library_fn (ansi_opname[(int) VEC_NEW_EXPR], newtype);
6308     global_delete_fndecl = push_cp_library_fn (ansi_opname[(int) DELETE_EXPR],
6309                                                deltype);
6310     push_cp_library_fn (ansi_opname[(int) VEC_DELETE_EXPR], deltype);
6311   }
6312
6313   abort_fndecl
6314     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6315
6316   /* Perform other language dependent initializations.  */
6317   init_class_processing ();
6318   init_init_processing ();
6319   init_search_processing ();
6320   init_rtti_processing ();
6321
6322   if (flag_exceptions)
6323     init_exception_processing ();
6324   if (flag_no_inline)
6325     {
6326       flag_inline_functions = 0;
6327     }
6328
6329   if (! supports_one_only ())
6330     flag_weak = 0;
6331
6332   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6333   make_fname_decl = cp_make_fname_decl;
6334   declare_function_name ();
6335
6336   /* Prepare to check format strings against argument lists.  */
6337   init_function_format_info ();
6338
6339   /* Show we use EH for cleanups.  */
6340   using_eh_for_cleanups ();
6341
6342   print_error_function = lang_print_error_function;
6343   lang_get_alias_set = &c_get_alias_set;
6344   valid_lang_attribute = cp_valid_lang_attribute;
6345
6346   /* Maintain consistency.  Perhaps we should just complain if they
6347      say -fwritable-strings?  */
6348   if (flag_writable_strings)
6349     flag_const_strings = 0;
6350
6351   /* Add GC roots for all of our global variables.  */
6352   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6353   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6354   ggc_add_tree_root (&integer_three_node, 1);
6355   ggc_add_tree_root (&integer_two_node, 1);
6356   ggc_add_tree_root (&signed_size_zero_node, 1);
6357   ggc_add_tree_root (&size_one_node, 1);
6358   ggc_add_tree_root (&size_zero_node, 1);
6359   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6360                 mark_binding_level);
6361   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6362   ggc_add_tree_root (&static_ctors, 1);
6363   ggc_add_tree_root (&static_dtors, 1);
6364   ggc_add_tree_root (&lastiddecl, 1);
6365
6366   ggc_add_tree_root (&last_function_parm_tags, 1);
6367   ggc_add_tree_root (&current_function_return_value, 1);
6368   ggc_add_tree_root (&current_function_parms, 1);
6369   ggc_add_tree_root (&current_function_parm_tags, 1);
6370   ggc_add_tree_root (&last_function_parms, 1);
6371   ggc_add_tree_root (&error_mark_list, 1);
6372
6373   ggc_add_tree_root (&global_namespace, 1);
6374   ggc_add_tree_root (&global_type_node, 1);
6375   ggc_add_tree_root (&anonymous_namespace_name, 1);
6376
6377   ggc_add_tree_root (&got_object, 1);
6378   ggc_add_tree_root (&got_scope, 1);
6379
6380   ggc_add_tree_root (&current_lang_name, 1);
6381   ggc_add_tree_root (&static_aggregates, 1);
6382 }
6383
6384 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6385    decl, NAME is the initialization string and TYPE_DEP indicates whether
6386    NAME depended on the type of the function. We make use of that to detect
6387    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6388    the function before emitting any of it, we don't need to treat the
6389    VAR_DECL specially. We can decide whether to emit it later, if it was
6390    used.  */
6391
6392 static tree
6393 cp_make_fname_decl (id, name, type_dep)
6394      tree id;
6395      const char *name;
6396      int type_dep;
6397 {
6398   tree decl, type, init;
6399   size_t length = strlen (name);
6400   tree domain = NULL_TREE;
6401
6402   if (!processing_template_decl)
6403     type_dep = 0;
6404   if (!type_dep)
6405     domain = build_index_type (build_int_2 (length, 0));
6406
6407   type =  build_cplus_array_type
6408           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6409            domain);
6410
6411   decl = build_lang_decl (VAR_DECL, id, type);
6412   TREE_STATIC (decl) = 1;
6413   TREE_READONLY (decl) = 1;
6414   DECL_SOURCE_LINE (decl) = 0;
6415   DECL_ARTIFICIAL (decl) = 1;
6416   DECL_IN_SYSTEM_HEADER (decl) = 1;
6417   pushdecl (decl);
6418   if (processing_template_decl)
6419     decl = push_template_decl (decl);
6420   if (type_dep)
6421     {
6422       init = build (FUNCTION_NAME, type);
6423       DECL_PRETTY_FUNCTION_P (decl) = 1;
6424     }
6425   else
6426     {
6427       init = build_string (length + 1, name);
6428       TREE_TYPE (init) = type;
6429     }
6430   DECL_INITIAL (decl) = init;
6431   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6432
6433   /* We will have to make sure we only emit this, if it is actually used. */
6434   return decl;
6435 }
6436
6437 /* Function to print any language-specific context for an error message.  */
6438
6439 static void
6440 lang_print_error_function (file)
6441      const char *file;
6442 {
6443   default_print_error_function (file);
6444   maybe_print_template_context ();
6445 }
6446
6447 /* Entry point for the benefit of c_common_nodes_and_builtins.
6448
6449    Make a definition for a builtin function named NAME and whose data type
6450    is TYPE.  TYPE should be a function type with argument types.
6451
6452    CLASS and CODE tell later passes how to compile calls to this function.
6453    See tree.h for possible values.
6454
6455    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6456    the name to be called if we can't opencode the function.  */
6457
6458 tree
6459 builtin_function (name, type, code, class, libname)
6460      const char *name;
6461      tree type;
6462      int code;
6463      enum built_in_class class;
6464      const char *libname;
6465 {
6466   tree decl = build_library_fn_1 (get_identifier (name), type);
6467   DECL_BUILT_IN_CLASS (decl) = class;
6468   DECL_FUNCTION_CODE (decl) = code;
6469
6470   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6471
6472   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6473      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6474      function in the namespace.  */
6475   pushdecl (decl);
6476   if (libname)
6477     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6478   make_function_rtl (decl);
6479   return decl;
6480 }
6481
6482 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6483    function.  Not called directly.  */
6484
6485 static tree
6486 build_library_fn_1 (name, type)
6487      tree name;
6488      tree type;
6489 {
6490   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6491   DECL_EXTERNAL (fn) = 1;
6492   TREE_PUBLIC (fn) = 1;
6493   DECL_ARTIFICIAL (fn) = 1;
6494   TREE_NOTHROW (fn) = 1;
6495   return fn;
6496 }
6497
6498 /* Returns the _DECL for a library function with C linkage.
6499    We assume that such functions never throw; if this is incorrect,
6500    callers should unset TREE_NOTHROW.  */
6501
6502 tree
6503 build_library_fn (name, type)
6504      tree name;
6505      tree type;
6506 {
6507   tree fn = build_library_fn_1 (name, type);
6508   make_function_rtl (fn);
6509   return fn;
6510 }
6511
6512 /* Returns the _DECL for a library function with C++ linkage.  */
6513
6514 tree
6515 build_cp_library_fn (name, type)
6516      tree name;
6517      tree type;
6518 {
6519   tree fn = build_library_fn_1 (name, type);
6520   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6521   set_mangled_name_for_decl (fn);
6522   make_function_rtl (fn);
6523   return fn;
6524 }
6525
6526 /* Like build_library_fn, but takes a C string instead of an
6527    IDENTIFIER_NODE.  */
6528
6529 tree
6530 build_library_fn_ptr (name, type)
6531      const char *name;
6532      tree type;
6533 {
6534   return build_library_fn (get_identifier (name), type);
6535 }
6536
6537 /* Like build_cp_library_fn, but takes a C string instead of an
6538    IDENTIFIER_NODE.  */
6539
6540 tree
6541 build_cp_library_fn_ptr (name, type)
6542      const char *name;
6543      tree type;
6544 {
6545   return build_cp_library_fn (get_identifier (name), type);
6546 }
6547
6548 /* Like build_library_fn, but also pushes the function so that we will
6549    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6550
6551 tree
6552 push_library_fn (name, type)
6553      tree name, type;
6554 {
6555   tree fn = build_library_fn (name, type);
6556   pushdecl_top_level (fn);
6557   return fn;
6558 }
6559
6560 /* Like build_cp_library_fn, but also pushes the function so that it
6561    will be found by normal lookup.  */
6562
6563 tree
6564 push_cp_library_fn (name, type)
6565      tree name;
6566      tree type;
6567 {
6568   tree fn = build_cp_library_fn (name, type);
6569   pushdecl (fn);
6570   return fn;
6571 }
6572
6573 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6574    a FUNCTION_TYPE.  */
6575
6576 tree
6577 push_void_library_fn (name, parmtypes)
6578      tree name, parmtypes;
6579 {
6580   tree type = build_function_type (void_type_node, parmtypes);
6581   return push_library_fn (name, type);
6582 }
6583
6584 /* Like push_library_fn, but also note that this function throws
6585    and does not return.  Used for __throw_foo and the like.  */
6586
6587 tree
6588 push_throw_library_fn (name, type)
6589      tree name, type;
6590 {
6591   tree fn = push_library_fn (name, type);
6592   TREE_THIS_VOLATILE (fn) = 1;
6593   TREE_NOTHROW (fn) = 0;
6594   return fn;
6595 }
6596 \f
6597 /* When we call finish_struct for an anonymous union, we create
6598    default copy constructors and such.  But, an anonymous union
6599    shouldn't have such things; this function undoes the damage to the
6600    anonymous union type T.
6601
6602    (The reason that we create the synthesized methods is that we don't
6603    distinguish `union { int i; }' from `typedef union { int i; } U'.
6604    The first is an anonymous union; the second is just an ordinary
6605    union type.)  */
6606
6607 void
6608 fixup_anonymous_aggr (t)
6609      tree t;
6610 {
6611   tree *q;
6612
6613   /* Wipe out memory of synthesized methods */
6614   TYPE_HAS_CONSTRUCTOR (t) = 0;
6615   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6616   TYPE_HAS_INIT_REF (t) = 0;
6617   TYPE_HAS_CONST_INIT_REF (t) = 0;
6618   TYPE_HAS_ASSIGN_REF (t) = 0;
6619   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6620
6621   /* Splice the implicitly generated functions out of the TYPE_METHODS
6622      list.  */
6623   q = &TYPE_METHODS (t);
6624   while (*q)
6625     {
6626       if (DECL_ARTIFICIAL (*q))
6627         *q = TREE_CHAIN (*q);
6628       else
6629         q = &TREE_CHAIN (*q);
6630     }
6631
6632   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6633   if (TYPE_METHODS (t))
6634     error ("an anonymous union cannot have function members");
6635 }
6636
6637 /* Make sure that a declaration with no declarator is well-formed, i.e.
6638    just defines a tagged type or anonymous union.
6639
6640    Returns the type defined, if any.  */
6641
6642 tree
6643 check_tag_decl (declspecs)
6644      tree declspecs;
6645 {
6646   int found_type = 0;
6647   tree ob_modifier = NULL_TREE;
6648   register tree link;
6649   register tree t = NULL_TREE;
6650
6651   for (link = declspecs; link; link = TREE_CHAIN (link))
6652     {
6653       register tree value = TREE_VALUE (link);
6654
6655       if (TYPE_P (value))
6656         {
6657           ++found_type;
6658
6659           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6660             {
6661               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6662               t = value;
6663             }
6664         }
6665       else if (value == ridpointers[(int) RID_FRIEND])
6666         {
6667           if (current_class_type == NULL_TREE
6668               || current_scope () != current_class_type)
6669             ob_modifier = value;
6670         }
6671       else if (value == ridpointers[(int) RID_STATIC]
6672                || value == ridpointers[(int) RID_EXTERN]
6673                || value == ridpointers[(int) RID_AUTO]
6674                || value == ridpointers[(int) RID_REGISTER]
6675                || value == ridpointers[(int) RID_INLINE]
6676                || value == ridpointers[(int) RID_VIRTUAL]
6677                || value == ridpointers[(int) RID_CONST]
6678                || value == ridpointers[(int) RID_VOLATILE]
6679                || value == ridpointers[(int) RID_EXPLICIT])
6680         ob_modifier = value;
6681     }
6682
6683   if (found_type > 1)
6684     error ("multiple types in one declaration");
6685
6686   /* Inside a class, we might be in a friend or access declaration.
6687      Until we have a good way of detecting the latter, don't warn.  */
6688   if (t == NULL_TREE && ! current_class_type)
6689     pedwarn ("declaration does not declare anything");
6690
6691   /* Check for an anonymous union.  We're careful
6692      accessing TYPE_IDENTIFIER because some built-in types, like
6693      pointer-to-member types, do not have TYPE_NAME.  */
6694   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6695            && TYPE_NAME (t)
6696            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6697     {
6698       /* Anonymous unions are objects, so they can have specifiers.  */;
6699       SET_ANON_AGGR_TYPE_P (t);
6700
6701       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6702         pedwarn ("ISO C++ prohibits anonymous structs");
6703     }
6704
6705   else if (ob_modifier)
6706     {
6707       if (ob_modifier == ridpointers[(int) RID_INLINE]
6708           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6709         cp_error ("`%D' can only be specified for functions", ob_modifier);
6710       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6711         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6712       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6713         cp_error ("`%D' can only be specified for constructors",
6714                   ob_modifier);
6715       else
6716         cp_error ("`%D' can only be specified for objects and functions",
6717                   ob_modifier);
6718     }
6719
6720   return t;
6721 }
6722
6723 /* Called when a declaration is seen that contains no names to declare.
6724    If its type is a reference to a structure, union or enum inherited
6725    from a containing scope, shadow that tag name for the current scope
6726    with a forward reference.
6727    If its type defines a new named structure or union
6728    or defines an enum, it is valid but we need not do anything here.
6729    Otherwise, it is an error.
6730
6731    C++: may have to grok the declspecs to learn about static,
6732    complain for anonymous unions.  */
6733
6734 void
6735 shadow_tag (declspecs)
6736      tree declspecs;
6737 {
6738   tree t = check_tag_decl (declspecs);
6739
6740   if (t)
6741     maybe_process_partial_specialization (t);
6742
6743   /* This is where the variables in an anonymous union are
6744      declared.  An anonymous union declaration looks like:
6745      union { ... } ;
6746      because there is no declarator after the union, the parser
6747      sends that declaration here.  */
6748   if (t && ANON_AGGR_TYPE_P (t))
6749     {
6750       fixup_anonymous_aggr (t);
6751
6752       if (TYPE_FIELDS (t))
6753         {
6754           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6755                                       NULL_TREE);
6756           finish_anon_union (decl);
6757         }
6758     }
6759 }
6760 \f
6761 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6762
6763 tree
6764 groktypename (typename)
6765      tree typename;
6766 {
6767   if (TREE_CODE (typename) != TREE_LIST)
6768     return typename;
6769   return grokdeclarator (TREE_VALUE (typename),
6770                          TREE_PURPOSE (typename),
6771                          TYPENAME, 0, NULL_TREE);
6772 }
6773
6774 /* Decode a declarator in an ordinary declaration or data definition.
6775    This is called as soon as the type information and variable name
6776    have been parsed, before parsing the initializer if any.
6777    Here we create the ..._DECL node, fill in its type,
6778    and put it on the list of decls for the current context.
6779    The ..._DECL node is returned as the value.
6780
6781    Exception: for arrays where the length is not specified,
6782    the type is left null, to be filled in by `cp_finish_decl'.
6783
6784    Function definitions do not come here; they go to start_function
6785    instead.  However, external and forward declarations of functions
6786    do go through here.  Structure field declarations are done by
6787    grokfield and not through here.  */
6788
6789 /* Set this to zero to debug not using the temporary obstack
6790    to parse initializers.  */
6791 int debug_temp_inits = 1;
6792
6793 tree
6794 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6795      tree declarator, declspecs;
6796      int initialized;
6797      tree attributes, prefix_attributes;
6798 {
6799   register tree decl;
6800   register tree type, tem;
6801   tree context;
6802   extern int have_extern_spec;
6803   extern int used_extern_spec;
6804   tree attrlist;
6805
6806 #if 0
6807   /* See code below that used this.  */
6808   int init_written = initialized;
6809 #endif
6810
6811   /* This should only be done once on the top most decl.  */
6812   if (have_extern_spec && !used_extern_spec)
6813     {
6814       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6815                                   declspecs);
6816       used_extern_spec = 1;
6817     }
6818
6819   if (attributes || prefix_attributes)
6820     attrlist = build_tree_list (attributes, prefix_attributes);
6821   else
6822     attrlist = NULL_TREE;
6823
6824   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6825                          attrlist);
6826
6827   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6828     return NULL_TREE;
6829
6830   type = TREE_TYPE (decl);
6831
6832   if (type == error_mark_node)
6833     return NULL_TREE;
6834
6835   context = DECL_CONTEXT (decl);
6836
6837   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
6838       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
6839     {
6840       /* When parsing the initializer, lookup should use the object's
6841          namespace. */
6842       push_decl_namespace (context);
6843     }
6844
6845   /* We are only interested in class contexts, later. */
6846   if (context && TREE_CODE (context) == NAMESPACE_DECL)
6847     context = NULL_TREE;
6848
6849   if (initialized)
6850     /* Is it valid for this decl to have an initializer at all?
6851        If not, set INITIALIZED to zero, which will indirectly
6852        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6853     switch (TREE_CODE (decl))
6854       {
6855       case TYPE_DECL:
6856         /* typedef foo = bar  means give foo the same type as bar.
6857            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6858            Any other case of an initialization in a TYPE_DECL is an error.  */
6859         if (pedantic || list_length (declspecs) > 1)
6860           {
6861             cp_error ("typedef `%D' is initialized", decl);
6862             initialized = 0;
6863           }
6864         break;
6865
6866       case FUNCTION_DECL:
6867         cp_error ("function `%#D' is initialized like a variable", decl);
6868         initialized = 0;
6869         break;
6870
6871       default:
6872         break;
6873       }
6874
6875   if (initialized)
6876     {
6877       if (! toplevel_bindings_p ()
6878           && DECL_EXTERNAL (decl))
6879         cp_warning ("declaration of `%#D' has `extern' and is initialized",
6880                     decl);
6881       DECL_EXTERNAL (decl) = 0;
6882       if (toplevel_bindings_p ())
6883         TREE_STATIC (decl) = 1;
6884
6885       /* Tell `pushdecl' this is an initialized decl
6886          even though we don't yet have the initializer expression.
6887          Also tell `cp_finish_decl' it may store the real initializer.  */
6888       DECL_INITIAL (decl) = error_mark_node;
6889     }
6890
6891 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
6892   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
6893 #endif
6894
6895   /* Set attributes here so if duplicate decl, will have proper attributes.  */
6896   cplus_decl_attributes (decl, attributes, prefix_attributes);
6897
6898   if (context && TYPE_SIZE (complete_type (context)) != NULL_TREE)
6899     {
6900       push_nested_class (context, 2);
6901
6902       if (TREE_CODE (decl) == VAR_DECL)
6903         {
6904           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
6905           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
6906             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
6907           else
6908             {
6909               if (DECL_CONTEXT (field) != context)
6910                 {
6911                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
6912                               DECL_CONTEXT (field), DECL_NAME (decl),
6913                               context, DECL_NAME (decl));
6914                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
6915                 }
6916               /* Static data member are tricky; an in-class initialization
6917                  still doesn't provide a definition, so the in-class
6918                  declaration will have DECL_EXTERNAL set, but will have an
6919                  initialization.  Thus, duplicate_decls won't warn
6920                  about this situation, and so we check here.  */
6921               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
6922                 cp_error ("duplicate initialization of %D", decl);
6923               if (duplicate_decls (decl, field))
6924                 decl = field;
6925             }
6926         }
6927       else
6928         {
6929           tree field = check_classfn (context, decl);
6930           if (field && duplicate_decls (decl, field))
6931             decl = field;
6932         }
6933
6934       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
6935       DECL_IN_AGGR_P (decl) = 0;
6936       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
6937           || CLASSTYPE_USE_TEMPLATE (context))
6938         {
6939           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
6940           /* [temp.expl.spec] An explicit specialization of a static data
6941              member of a template is a definition if the declaration
6942              includes an initializer; otherwise, it is a declaration.
6943
6944              We check for processing_specialization so this only applies
6945              to the new specialization syntax.  */
6946           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
6947             DECL_EXTERNAL (decl) = 1;
6948         }
6949
6950       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
6951         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6952                     decl);
6953     }
6954
6955   /* Enter this declaration into the symbol table.  */
6956   tem = maybe_push_decl (decl);
6957
6958   if (processing_template_decl)
6959     tem = push_template_decl (tem);
6960
6961 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6962   /* Tell the back-end to use or not use .common as appropriate.  If we say
6963      -fconserve-space, we want this to save .data space, at the expense of
6964      wrong semantics.  If we say -fno-conserve-space, we want this to
6965      produce errors about redefs; to do this we force variables into the
6966      data segment.  */
6967   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
6968 #endif
6969
6970   if (! processing_template_decl)
6971     start_decl_1 (tem);
6972
6973   return tem;
6974 }
6975
6976 void
6977 start_decl_1 (decl)
6978      tree decl;
6979 {
6980   tree type = TREE_TYPE (decl);
6981   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
6982
6983   if (type == error_mark_node)
6984     return;
6985
6986   /* If this type of object needs a cleanup, but we're not allowed to
6987      add any more objects with cleanups to the current scope, create a
6988      new binding level.  */
6989   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6990       && current_binding_level->more_cleanups_ok == 0)
6991     {
6992       keep_next_level (2);
6993       pushlevel (1);
6994       clear_last_expr ();
6995       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
6996     }
6997
6998   if (initialized)
6999     /* Is it valid for this decl to have an initializer at all?
7000        If not, set INITIALIZED to zero, which will indirectly
7001        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7002     {
7003       /* Don't allow initializations for incomplete types except for
7004          arrays which might be completed by the initialization.  */
7005       if (TYPE_SIZE (complete_type (type)) != NULL_TREE)
7006         ;                       /* A complete type is ok.  */
7007       else if (TREE_CODE (type) != ARRAY_TYPE)
7008         {
7009           cp_error ("variable `%#D' has initializer but incomplete type",
7010                     decl);
7011           initialized = 0;
7012           type = TREE_TYPE (decl) = error_mark_node;
7013         }
7014       else if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
7015         {
7016           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7017             cp_error ("elements of array `%#D' have incomplete type", decl);
7018           /* else we already gave an error in start_decl.  */
7019           initialized = 0;
7020         }
7021     }
7022
7023   if (!initialized
7024       && TREE_CODE (decl) != TYPE_DECL
7025       && TREE_CODE (decl) != TEMPLATE_DECL
7026       && type != error_mark_node
7027       && IS_AGGR_TYPE (type)
7028       && ! DECL_EXTERNAL (decl))
7029     {
7030       if ((! processing_template_decl || ! uses_template_parms (type))
7031           && TYPE_SIZE (complete_type (type)) == NULL_TREE)
7032         {
7033           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7034                  decl);
7035           /* Change the type so that assemble_variable will give
7036              DECL an rtl we can live with: (mem (const_int 0)).  */
7037           type = TREE_TYPE (decl) = error_mark_node;
7038         }
7039       else
7040         {
7041           /* If any base type in the hierarchy of TYPE needs a constructor,
7042              then we set initialized to 1.  This way any nodes which are
7043              created for the purposes of initializing this aggregate
7044              will live as long as it does.  This is necessary for global
7045              aggregates which do not have their initializers processed until
7046              the end of the file.  */
7047           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7048         }
7049     }
7050
7051   if (! initialized)
7052     DECL_INITIAL (decl) = NULL_TREE;
7053 }
7054
7055 /* Handle initialization of references.
7056    These three arguments are from `cp_finish_decl', and have the
7057    same meaning here that they do there.
7058
7059    Quotes on semantics can be found in ARM 8.4.3.  */
7060
7061 static void
7062 grok_reference_init (decl, type, init)
7063      tree decl, type, init;
7064 {
7065   tree tmp;
7066
7067   if (init == NULL_TREE)
7068     {
7069       if ((DECL_LANG_SPECIFIC (decl) == 0
7070            || DECL_IN_AGGR_P (decl) == 0)
7071           && ! DECL_THIS_EXTERN (decl))
7072         cp_error ("`%D' declared as reference but not initialized", decl);
7073       return;
7074     }
7075
7076   if (init == error_mark_node)
7077     return;
7078
7079   if (TREE_CODE (init) == CONSTRUCTOR)
7080     {
7081       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7082       return;
7083     }
7084
7085   if (TREE_CODE (init) == TREE_LIST)
7086     init = build_compound_expr (init);
7087
7088   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7089     init = convert_from_reference (init);
7090
7091   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7092       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7093     {
7094       /* Note: default conversion is only called in very special cases.  */
7095       init = default_conversion (init);
7096     }
7097
7098   /* Convert INIT to the reference type TYPE.  This may involve the
7099      creation of a temporary, whose lifetime must be the same as that
7100      of the reference.  If so, a DECL_STMT for the temporary will be
7101      added just after the DECL_STMT for DECL.  That's why we don't set
7102      DECL_INITIAL for local references (instead assigning to them
7103      explicitly); we need to allow the temporary to be initialized
7104      first.  */
7105   tmp = convert_to_reference
7106     (type, init, CONV_IMPLICIT,
7107      LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
7108
7109   if (tmp == error_mark_node)
7110     return;
7111   else if (tmp != NULL_TREE)
7112     {
7113       init = tmp;
7114       tmp = save_expr (tmp);
7115       if (building_stmt_tree ())
7116         {
7117           /* Initialize the declaration.  */
7118           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7119           finish_expr_stmt (tmp);
7120         }
7121       else
7122         DECL_INITIAL (decl) = tmp;
7123     }
7124   else
7125     {
7126       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7127       return;
7128     }
7129
7130   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7131     {
7132       expand_static_init (decl, DECL_INITIAL (decl));
7133       DECL_INITIAL (decl) = NULL_TREE;
7134     }
7135   return;
7136 }
7137
7138 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7139    mucking with forces it does not comprehend (i.e. initialization with a
7140    constructor).  If we are at global scope and won't go into COMMON, fill
7141    it in with a dummy CONSTRUCTOR to force the variable into .data;
7142    otherwise we can use error_mark_node.  */
7143
7144 static tree
7145 obscure_complex_init (decl, init)
7146      tree decl, init;
7147 {
7148   if (! flag_no_inline && TREE_STATIC (decl))
7149     {
7150       if (extract_init (decl, init))
7151         return NULL_TREE;
7152     }
7153
7154 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7155   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7156     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7157                                  NULL_TREE);
7158   else
7159 #endif
7160     DECL_INITIAL (decl) = error_mark_node;
7161
7162   return init;
7163 }
7164
7165 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7166    array until we finish parsing the initializer.  If that's the
7167    situation we're in, update DECL accordingly.  */
7168
7169 static void
7170 maybe_deduce_size_from_array_init (decl, init)
7171      tree decl;
7172      tree init;
7173 {
7174   tree type = TREE_TYPE (decl);
7175
7176   if (TREE_CODE (type) == ARRAY_TYPE
7177       && TYPE_DOMAIN (type) == NULL_TREE
7178       && TREE_CODE (decl) != TYPE_DECL)
7179     {
7180       int do_default
7181         = (TREE_STATIC (decl)
7182            /* Even if pedantic, an external linkage array
7183               may have incomplete type at first.  */
7184            ? pedantic && ! DECL_EXTERNAL (decl)
7185            : !DECL_EXTERNAL (decl));
7186       tree initializer = init ? init : DECL_INITIAL (decl);
7187       int failure = complete_array_type (type, initializer, do_default);
7188
7189       if (failure == 1)
7190         cp_error ("initializer fails to determine size of `%D'", decl);
7191
7192       if (failure == 2)
7193         {
7194           if (do_default)
7195             cp_error ("array size missing in `%D'", decl);
7196           /* If a `static' var's size isn't known, make it extern as
7197              well as static, so it does not get allocated.  If it's not
7198              `static', then don't mark it extern; finish_incomplete_decl
7199              will give it a default size and it will get allocated.  */
7200           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7201             DECL_EXTERNAL (decl) = 1;
7202         }
7203
7204       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7205           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7206                               integer_zero_node))
7207         cp_error ("zero-size array `%D'", decl);
7208
7209       layout_decl (decl, 0);
7210     }
7211 }
7212
7213 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7214    any appropriate error messages regarding the layout.  */
7215
7216 static void
7217 layout_var_decl (decl)
7218      tree decl;
7219 {
7220   tree type = TREE_TYPE (decl);
7221 #if 0
7222   tree ttype = target_type (type);
7223 #endif
7224
7225   /* If we haven't already layed out this declaration, do so now.
7226      Note that we must not call complete type for an external object
7227      because it's type might involve templates that we are not
7228      supposed to isntantiate yet.  (And it's perfectly legal to say
7229      `extern X x' for some incomplete type `X'.)  */
7230   if (!DECL_EXTERNAL (decl))
7231     complete_type (type);
7232   if (!DECL_SIZE (decl) && TYPE_SIZE (type))
7233     layout_decl (decl, 0);
7234
7235   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7236     {
7237       /* An automatic variable with an incomplete type: that is an error.
7238          Don't talk about array types here, since we took care of that
7239          message in grokdeclarator.  */
7240       cp_error ("storage size of `%D' isn't known", decl);
7241       TREE_TYPE (decl) = error_mark_node;
7242     }
7243 #if 0
7244   /* Keep this code around in case we later want to control debug info
7245      based on whether a type is "used".  (jason 1999-11-11) */
7246
7247   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7248     /* Let debugger know it should output info for this type.  */
7249     note_debug_info_needed (ttype);
7250
7251   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7252     note_debug_info_needed (DECL_CONTEXT (decl));
7253 #endif
7254
7255   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7256       && DECL_SIZE (decl) != NULL_TREE
7257       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7258     {
7259       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7260         constant_expression_warning (DECL_SIZE (decl));
7261       else
7262         cp_error ("storage size of `%D' isn't constant", decl);
7263     }
7264 }
7265
7266 /* If a local static variable is declared in an inline function, or if
7267    we have a weak definition, we must endeavor to create only one
7268    instance of the variable at link-time.  */
7269
7270 static void
7271 maybe_commonize_var (decl)
7272      tree decl;
7273 {
7274   /* Static data in a function with comdat linkage also has comdat
7275      linkage.  */
7276   if (TREE_STATIC (decl)
7277       /* Don't mess with __FUNCTION__.  */
7278       && ! DECL_ARTIFICIAL (decl)
7279       && current_function_decl
7280       && DECL_CONTEXT (decl) == current_function_decl
7281       && (DECL_THIS_INLINE (current_function_decl)
7282           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7283       && TREE_PUBLIC (current_function_decl))
7284     {
7285       /* Rather than try to get this right with inlining, we suppress
7286          inlining of such functions.  */
7287       current_function_cannot_inline
7288         = "function with static variable cannot be inline";
7289
7290       /* If flag_weak, we don't need to mess with this, as we can just
7291          make the function weak, and let it refer to its unique local
7292          copy.  This works because we don't allow the function to be
7293          inlined.  */
7294       if (! flag_weak)
7295         {
7296           if (DECL_INTERFACE_KNOWN (current_function_decl))
7297             {
7298               TREE_PUBLIC (decl) = 1;
7299               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7300             }
7301           else if (DECL_INITIAL (decl) == NULL_TREE
7302                    || DECL_INITIAL (decl) == error_mark_node)
7303             {
7304               TREE_PUBLIC (decl) = 1;
7305               DECL_COMMON (decl) = 1;
7306             }
7307           /* else we lose. We can only do this if we can use common,
7308              which we can't if it has been initialized.  */
7309
7310           if (TREE_PUBLIC (decl))
7311             DECL_ASSEMBLER_NAME (decl)
7312               = build_static_name (current_function_decl, DECL_NAME (decl));
7313           else
7314             {
7315               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7316               cp_warning_at ("  you can work around this by removing the initializer", decl);
7317             }
7318         }
7319     }
7320   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7321     /* Set it up again; we might have set DECL_INITIAL since the last
7322        time.  */
7323     comdat_linkage (decl);
7324 }
7325
7326 /* Issue an error message if DECL is an uninitialized const variable.  */
7327
7328 static void
7329 check_for_uninitialized_const_var (decl)
7330      tree decl;
7331 {
7332   tree type = TREE_TYPE (decl);
7333
7334   /* ``Unless explicitly declared extern, a const object does not have
7335      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7336      7.1.6 */
7337   if (TREE_CODE (decl) == VAR_DECL
7338       && TREE_CODE (type) != REFERENCE_TYPE
7339       && CP_TYPE_CONST_P (type)
7340       && !TYPE_NEEDS_CONSTRUCTING (type)
7341       && !DECL_INITIAL (decl))
7342     cp_error ("uninitialized const `%D'", decl);
7343 }
7344
7345 /* Verify INIT (the initializer for DECL), and record the
7346    initialization in DECL_INITIAL, if appropriate.  Returns a new
7347    value for INIT.  */
7348
7349 static tree
7350 check_initializer (decl, init)
7351      tree decl;
7352      tree init;
7353 {
7354   tree type;
7355
7356   if (TREE_CODE (decl) == FIELD_DECL)
7357     return init;
7358
7359   type = TREE_TYPE (decl);
7360
7361   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7362   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7363     init = NULL_TREE;
7364
7365   /* Check the initializer.  */
7366   if (init)
7367     {
7368       /* Things that are going to be initialized need to have complete
7369          type.  */
7370       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7371
7372       if (type == error_mark_node)
7373         /* We will have already complained.  */
7374         init = NULL_TREE;
7375       else if (TYPE_SIZE (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7376         {
7377           cp_error ("variable-sized object `%D' may not be initialized", decl);
7378           init = NULL_TREE;
7379         }
7380       else if (TREE_CODE (type) == ARRAY_TYPE
7381                && !TYPE_SIZE (TREE_TYPE (type)))
7382         {
7383           cp_error ("elements of array `%#D' have incomplete type", decl);
7384           init = NULL_TREE;
7385         }
7386       else if (!TYPE_SIZE (type))
7387         {
7388           cp_error ("`%D' has incomplete type", decl);
7389           TREE_TYPE (decl) = error_mark_node;
7390           init = NULL_TREE;
7391         }
7392     }
7393
7394   if (TREE_CODE (decl) == CONST_DECL)
7395     {
7396       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7397
7398       DECL_INITIAL (decl) = init;
7399
7400       /* This will keep us from needing to worry about our obstacks.  */
7401       my_friendly_assert (init != NULL_TREE, 149);
7402       init = NULL_TREE;
7403     }
7404   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7405     {
7406       if (TREE_STATIC (decl))
7407         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7408       grok_reference_init (decl, type, init);
7409       init = NULL_TREE;
7410     }
7411   else if (init)
7412     {
7413       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7414         {
7415           if (TREE_CODE (type) == ARRAY_TYPE)
7416             init = digest_init (type, init, (tree *) 0);
7417           else if (TREE_CODE (init) == CONSTRUCTOR
7418                    && TREE_HAS_CONSTRUCTOR (init))
7419             {
7420               if (TYPE_NON_AGGREGATE_CLASS (type))
7421                 {
7422                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7423                             decl);
7424                   init = error_mark_node;
7425                 }
7426               else
7427                 goto dont_use_constructor;
7428             }
7429         }
7430       else
7431         {
7432         dont_use_constructor:
7433           if (TREE_CODE (init) != TREE_VEC)
7434             init = store_init_value (decl, init);
7435         }
7436
7437       if (init)
7438         /* We must hide the initializer so that expand_decl
7439            won't try to do something it does not understand.  */
7440         init = obscure_complex_init (decl, init);
7441     }
7442   else if (DECL_EXTERNAL (decl))
7443     ;
7444   else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
7445            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7446     {
7447       tree core_type = strip_array_types (type);
7448
7449       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7450         {
7451           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7452             cp_error ("structure `%D' with uninitialized const members", decl);
7453           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7454             cp_error ("structure `%D' with uninitialized reference members",
7455                       decl);
7456         }
7457
7458       check_for_uninitialized_const_var (decl);
7459
7460       if (TYPE_SIZE (type) != NULL_TREE
7461           && TYPE_NEEDS_CONSTRUCTING (type))
7462         init = obscure_complex_init (decl, NULL_TREE);
7463
7464     }
7465   else
7466     check_for_uninitialized_const_var (decl);
7467
7468   return init;
7469 }
7470
7471 /* If DECL is not a local variable, give it RTL.  */
7472
7473 static void
7474 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7475      tree decl;
7476      tree init;
7477      const char *asmspec;
7478 {
7479   int toplev;
7480   tree type;
7481
7482   type = TREE_TYPE (decl);
7483   toplev = toplevel_bindings_p ();
7484
7485   /* Handle non-variables up front.  */
7486   if (TREE_CODE (decl) != VAR_DECL)
7487     {
7488       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7489       return;
7490     }
7491
7492   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7493   if (asmspec)
7494     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7495
7496   if (DECL_VIRTUAL_P (decl))
7497     make_decl_rtl (decl, NULL_PTR, toplev);
7498   else if (TREE_READONLY (decl)
7499            && DECL_INITIAL (decl) != NULL_TREE
7500            && DECL_INITIAL (decl) != error_mark_node
7501            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7502     {
7503       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7504
7505       if (toplev && ! TREE_PUBLIC (decl))
7506         {
7507           /* If this is a static const, change its apparent linkage
7508              if it belongs to a #pragma interface.  */
7509           if (!interface_unknown)
7510             {
7511               TREE_PUBLIC (decl) = 1;
7512               DECL_EXTERNAL (decl) = interface_only;
7513             }
7514           make_decl_rtl (decl, asmspec, toplev);
7515         }
7516       else if (toplev)
7517         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7518     }
7519   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7520     {
7521       my_friendly_assert (TREE_STATIC (decl), 19990828);
7522
7523       if (init == NULL_TREE
7524 #ifdef DEFAULT_STATIC_DEFS
7525           /* If this code is dead, then users must
7526              explicitly declare static member variables
7527              outside the class def'n as well.  */
7528           && TYPE_NEEDS_CONSTRUCTING (type)
7529 #endif
7530           )
7531         {
7532           DECL_EXTERNAL (decl) = 1;
7533           make_decl_rtl (decl, asmspec, 1);
7534         }
7535       else
7536         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7537     }
7538   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7539            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7540     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7541 }
7542
7543 /* Create RTL for the local static variable DECL.  */
7544
7545 void
7546 make_rtl_for_local_static (decl)
7547      tree decl;
7548 {
7549   const char *asmspec = NULL;
7550
7551   /* If we inlined this variable, we could see it's declaration
7552      again.  */
7553   if (DECL_RTL (decl))
7554     return;
7555
7556   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7557     {
7558       /* The only way this situaton can occur is if the
7559          user specified a name for this DECL using the
7560          `attribute' syntax.  */
7561       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7562       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7563     }
7564
7565   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7566 }
7567
7568 /* The old ARM scoping rules injected variables declared in the
7569    initialization statement of a for-statement into the surrounding
7570    scope.  We support this usage, in order to be backward-compatible.
7571    DECL is a just-declared VAR_DECL; if necessary inject its
7572    declaration into the surrounding scope.  */
7573
7574 void
7575 maybe_inject_for_scope_var (decl)
7576      tree decl;
7577 {
7578   if (current_binding_level->is_for_scope)
7579     {
7580       struct binding_level *outer
7581         = current_binding_level->level_chain;
7582
7583       /* Check to see if the same name is already bound at the outer
7584          level, either because it was directly declared, or because a
7585          dead for-decl got preserved.  In either case, the code would
7586          not have been valid under the ARM scope rules, so clear
7587          is_for_scope for the current_binding_level.
7588
7589          Otherwise, we need to preserve the temp slot for decl to last
7590          into the outer binding level.  */
7591
7592       tree outer_binding
7593         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7594
7595       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7596           && (TREE_CODE (BINDING_VALUE (outer_binding))
7597               == VAR_DECL)
7598           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7599         {
7600           BINDING_VALUE (outer_binding)
7601             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7602           current_binding_level->is_for_scope = 0;
7603         }
7604       else if (DECL_IN_MEMORY_P (decl))
7605         preserve_temp_slots (DECL_RTL (decl));
7606     }
7607 }
7608
7609 /* Generate code to initialize DECL (a local variable).  */
7610
7611 void
7612 initialize_local_var (decl, init, flags)
7613      tree decl;
7614      tree init;
7615      int flags;
7616 {
7617   tree type = TREE_TYPE (decl);
7618
7619   /* If the type is bogus, don't bother initializing the variable.  */
7620   if (type == error_mark_node)
7621     return;
7622
7623   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7624     {
7625       /* If we used it already as memory, it must stay in memory.  */
7626       DECL_INITIAL (decl) = NULL_TREE;
7627       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7628     }
7629
7630   /* Local statics are handled differently from ordinary automatic
7631      variables.  */
7632   if (TREE_STATIC (decl))
7633     {
7634       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7635           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7636         expand_static_init (decl, init);
7637       return;
7638     }
7639
7640   if (DECL_SIZE (decl) && type != error_mark_node)
7641     {
7642       int already_used;
7643
7644       /* Compute and store the initial value.  */
7645       already_used = TREE_USED (decl) || TREE_USED (type);
7646
7647       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7648         {
7649           int saved_stmts_are_full_exprs_p;
7650
7651           emit_line_note (DECL_SOURCE_FILE (decl),
7652                           DECL_SOURCE_LINE (decl));
7653           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7654           stmts_are_full_exprs_p = 1;
7655           finish_expr_stmt (build_aggr_init (decl, init, flags));
7656           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7657         }
7658
7659       /* Set this to 0 so we can tell whether an aggregate which was
7660          initialized was ever used.  Don't do this if it has a
7661          destructor, so we don't complain about the 'resource
7662          allocation is initialization' idiom.  Now set
7663          attribute((unused)) on types so decls of that type will be
7664          marked used. (see TREE_USED, above.)  */
7665       if (TYPE_NEEDS_CONSTRUCTING (type)
7666           && ! already_used
7667           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7668           && DECL_NAME (decl))
7669         TREE_USED (decl) = 0;
7670       else if (already_used)
7671         TREE_USED (decl) = 1;
7672     }
7673 }
7674
7675 /* Generate code to destroy DECL (a local variable).  */
7676
7677 static void
7678 destroy_local_var (decl)
7679      tree decl;
7680 {
7681   tree type = TREE_TYPE (decl);
7682   tree cleanup;
7683
7684   /* Only variables get cleaned up.  */
7685   if (TREE_CODE (decl) != VAR_DECL)
7686     return;
7687
7688   /* And only things with destructors need cleaning up.  */
7689   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7690     return;
7691
7692   if (TREE_CODE (decl) == VAR_DECL &&
7693       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7694     /* We don't clean up things that aren't defined in this
7695        translation unit, or that need a static cleanup.  The latter
7696        are handled by finish_file.  */
7697     return;
7698
7699   /* Compute the cleanup.  */
7700   cleanup = maybe_build_cleanup (decl);
7701
7702   /* Record the cleanup required for this declaration.  */
7703   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7704       && cleanup)
7705     finish_decl_cleanup (decl, cleanup);
7706 }
7707
7708 /* Let the back-end know about DECL.  */
7709
7710 void
7711 emit_local_var (decl)
7712      tree decl;
7713 {
7714   /* Create RTL for this variable.  */
7715   if (DECL_RTL (decl))
7716     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7717        All other local variables are assigned RTL in this function.  */
7718     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
7719                         19990828);
7720   else
7721     {
7722       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7723         /* The user must have specified an assembler name for this
7724            variable.  Set that up now.  */
7725         rest_of_decl_compilation
7726           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
7727            /*top_level=*/0, /*at_end=*/0);
7728       else
7729         expand_decl (decl);
7730     }
7731
7732   /* Actually do the initialization.  */
7733   expand_start_target_temps ();
7734   expand_decl_init (decl);
7735   expand_end_target_temps ();
7736 }
7737
7738 /* Finish processing of a declaration;
7739    install its line number and initial value.
7740    If the length of an array type is not known before,
7741    it must be determined now, from the initial value, or it is an error.
7742
7743    INIT0 holds the value of an initializer that should be allowed to escape
7744    the normal rules.
7745
7746    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7747    if the (init) syntax was used.
7748
7749    For functions that take default parameters, DECL points to its
7750    "maximal" instantiation.  `cp_finish_decl' must then also declared its
7751    subsequently lower and lower forms of instantiation, checking for
7752    ambiguity as it goes.  This can be sped up later.  */
7753
7754 void
7755 cp_finish_decl (decl, init, asmspec_tree, flags)
7756      tree decl, init;
7757      tree asmspec_tree;
7758      int flags;
7759 {
7760   register tree type;
7761   tree ttype = NULL_TREE;
7762   const char *asmspec = NULL;
7763   int was_readonly = 0;
7764
7765   if (! decl)
7766     {
7767       if (init)
7768         error ("assignment (not initialization) in declaration");
7769       return;
7770     }
7771
7772   /* If a name was specified, get the string.  */
7773   if (asmspec_tree)
7774       asmspec = TREE_STRING_POINTER (asmspec_tree);
7775
7776   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7777     {
7778       cp_error ("cannot initialize `%D' to namespace `%D'",
7779                 decl, init);
7780       init = NULL_TREE;
7781     }
7782
7783   if (current_class_type
7784       && CP_DECL_CONTEXT (decl) == current_class_type
7785       && TYPE_BEING_DEFINED (current_class_type)
7786       && (DECL_INITIAL (decl) || init))
7787     DECL_DEFINED_IN_CLASS_P (decl) = 1;
7788
7789   if (TREE_CODE (decl) == VAR_DECL
7790       && DECL_CONTEXT (decl)
7791       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7792       && DECL_CONTEXT (decl) != current_namespace
7793       && init)
7794     {
7795       /* Leave the namespace of the object. */
7796       pop_decl_namespace ();
7797     }
7798
7799   type = TREE_TYPE (decl);
7800
7801   if (type == error_mark_node)
7802     return;
7803
7804   /* Add this declaration to the statement-tree.  */
7805   if (building_stmt_tree () && at_function_scope_p ())
7806     add_decl_stmt (decl);
7807
7808   if (TYPE_HAS_MUTABLE_P (type))
7809     TREE_READONLY (decl) = 0;
7810
7811   if (processing_template_decl)
7812     {
7813       if (init && DECL_INITIAL (decl))
7814         DECL_INITIAL (decl) = init;
7815       goto finish_end0;
7816     }
7817
7818   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7819   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7820
7821   /* Take care of TYPE_DECLs up front.  */
7822   if (TREE_CODE (decl) == TYPE_DECL)
7823     {
7824       if (init && DECL_INITIAL (decl))
7825         {
7826           /* typedef foo = bar; store the type of bar as the type of foo.  */
7827           TREE_TYPE (decl) = type = TREE_TYPE (init);
7828           DECL_INITIAL (decl) = init = NULL_TREE;
7829         }
7830       if (type != error_mark_node
7831           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7832         {
7833           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7834             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7835           set_identifier_type_value (DECL_NAME (decl), type);
7836           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7837         }
7838       GNU_xref_decl (current_function_decl, decl);
7839
7840       /* If we have installed this as the canonical typedef for this
7841          type, and that type has not been defined yet, delay emitting
7842          the debug information for it, as we will emit it later.  */
7843       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7844           && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
7845         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7846
7847       rest_of_decl_compilation (decl, NULL_PTR,
7848                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7849       goto finish_end;
7850     }
7851
7852   if (TREE_CODE (decl) != FUNCTION_DECL)
7853     ttype = target_type (type);
7854
7855   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7856       && TYPE_NEEDS_CONSTRUCTING (type))
7857     {
7858       /* Currently, GNU C++ puts constants in text space, making them
7859          impossible to initialize.  In the future, one would hope for
7860          an operating system which understood the difference between
7861          initialization and the running of a program.  */
7862       was_readonly = 1;
7863       TREE_READONLY (decl) = 0;
7864     }
7865
7866   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
7867     {
7868       /* This must override the asm specifier which was placed by
7869          grokclassfn.  Lay this out fresh.  */
7870       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
7871       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7872       make_decl_rtl (decl, asmspec, 0);
7873     }
7874
7875   /* Deduce size of array from initialization, if not already known.  */
7876   maybe_deduce_size_from_array_init (decl, init);
7877   init = check_initializer (decl, init);
7878
7879   GNU_xref_decl (current_function_decl, decl);
7880
7881   if (TREE_CODE (decl) == VAR_DECL)
7882     layout_var_decl (decl);
7883
7884   /* Output the assembler code and/or RTL code for variables and functions,
7885      unless the type is an undefined structure or union.
7886      If not, it will get done when the type is completed.  */
7887   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
7888       || TREE_CODE (decl) == RESULT_DECL)
7889     {
7890       if (TREE_CODE (decl) == VAR_DECL)
7891         maybe_commonize_var (decl);
7892
7893       make_rtl_for_nonlocal_decl (decl, init, asmspec);
7894
7895       if (TREE_CODE (type) == FUNCTION_TYPE
7896           || TREE_CODE (type) == METHOD_TYPE)
7897         abstract_virtuals_error (decl,
7898                                  strip_array_types (TREE_TYPE (type)));
7899       else
7900         abstract_virtuals_error (decl, strip_array_types (type));
7901
7902       if (TREE_CODE (decl) == FUNCTION_DECL)
7903         ;
7904       else if (DECL_EXTERNAL (decl)
7905                && ! (DECL_LANG_SPECIFIC (decl)
7906                      && DECL_NOT_REALLY_EXTERN (decl)))
7907         {
7908           if (init)
7909             DECL_INITIAL (decl) = init;
7910         }
7911       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
7912         {
7913           /* This is a local declaration.  */
7914           if (doing_semantic_analysis_p ())
7915             maybe_inject_for_scope_var (decl);
7916           /* Initialize the local variable.  But, if we're building a
7917              statement-tree, we'll do the initialization when we
7918              expand the tree.  */
7919           if (processing_template_decl)
7920             {
7921               if (init || DECL_INITIAL (decl) == error_mark_node)
7922                 DECL_INITIAL (decl) = init;
7923             }
7924           else
7925             {
7926               /* If we're not building RTL, then we need to do so
7927                  now.  */
7928               if (!building_stmt_tree ())
7929                 emit_local_var (decl);
7930               /* Initialize the variable.  */
7931               initialize_local_var (decl, init, flags);
7932               /* Clean up the variable.  */
7933               destroy_local_var (decl);
7934             }
7935         }
7936       else if (TREE_STATIC (decl) && type != error_mark_node)
7937         {
7938           /* Cleanups for static variables are handled by `finish_file'.  */
7939           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7940               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7941             expand_static_init (decl, init);
7942         }
7943     finish_end0:
7944
7945       /* Undo call to `pushclass' that was done in `start_decl'
7946          due to initialization of qualified member variable.
7947          I.e., Foo::x = 10;  */
7948       {
7949         tree context = CP_DECL_CONTEXT (decl);
7950         if (context
7951             && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
7952             && (TREE_CODE (decl) == VAR_DECL
7953                 /* We also have a pushclass done that we need to undo here
7954                    if we're at top level and declare a method.  */
7955                 || TREE_CODE (decl) == FUNCTION_DECL)
7956             /* If size hasn't been set, we're still defining it,
7957                and therefore inside the class body; don't pop
7958                the binding level..  */
7959             && TYPE_SIZE (context) != NULL_TREE
7960             && context == current_class_type)
7961           pop_nested_class ();
7962       }
7963     }
7964
7965  finish_end:
7966
7967   if (was_readonly)
7968     TREE_READONLY (decl) = 1;
7969 }
7970
7971 /* This is here for a midend callback from c-common.c */
7972
7973 void
7974 finish_decl (decl, init, asmspec_tree)
7975      tree decl, init;
7976      tree asmspec_tree;
7977 {
7978   cp_finish_decl (decl, init, asmspec_tree, 0);
7979 }
7980
7981 /* Returns a declaration for a VAR_DECL as if:
7982
7983      extern "C" TYPE NAME;
7984
7985    had been seen.  Used to create compiler-generated global
7986    variables.  */
7987
7988 tree
7989 declare_global_var (name, type)
7990      tree name;
7991      tree type;
7992 {
7993   tree decl;
7994
7995   push_to_top_level ();
7996   decl = build_decl (VAR_DECL, name, type);
7997   TREE_PUBLIC (decl) = 1;
7998   DECL_EXTERNAL (decl) = 1;
7999   DECL_ARTIFICIAL (decl) = 1;
8000   pushdecl (decl);
8001   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8002   pop_from_top_level ();
8003
8004   return decl;
8005 }
8006
8007 /* Returns a pointer to the `atexit' function.  Note that if
8008    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8009    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8010
8011 static tree
8012 get_atexit_node ()
8013 {
8014   tree atexit_fndecl;
8015   tree arg_types;
8016   tree fn_type;
8017   tree fn_ptr_type;
8018   const char *name;
8019
8020   if (atexit_node)
8021     return atexit_node;
8022
8023   if (flag_use_cxa_atexit)
8024     {
8025       /* The declaration for `__cxa_atexit' is:
8026
8027            int __cxa_atexit (void (*)(void *), void *, void *)
8028
8029          We build up the argument types and then then function type
8030          itself.  */
8031
8032       /* First, build the pointer-to-function type for the first
8033          argument.  */
8034       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8035       fn_type = build_function_type (void_type_node, arg_types);
8036       fn_ptr_type = build_pointer_type (fn_type);
8037       /* Then, build the rest of the argument types.  */
8038       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8039       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8040       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8041       /* And the final __cxa_atexit type.  */
8042       fn_type = build_function_type (integer_type_node, arg_types);
8043       fn_ptr_type = build_pointer_type (fn_type);
8044       name = "__cxa_atexit";
8045     }
8046   else
8047     {
8048       /* The declaration for `atexit' is:
8049
8050            int atexit (void (*)());
8051
8052          We build up the argument types and then then function type
8053          itself.  */
8054       fn_type = build_function_type (void_type_node, void_list_node);
8055       fn_ptr_type = build_pointer_type (fn_type);
8056       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8057       /* Build the final atexit type.  */
8058       fn_type = build_function_type (integer_type_node, arg_types);
8059       name = "atexit";
8060     }
8061
8062   /* Now, build the function declaration.  */
8063   push_lang_context (lang_name_c);
8064   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8065   mark_used (atexit_fndecl);
8066   pop_lang_context ();
8067   atexit_node = default_conversion (atexit_fndecl);
8068
8069   return atexit_node;
8070 }
8071
8072 /* Returns the __dso_handle VAR_DECL.  */
8073
8074 static tree
8075 get_dso_handle_node ()
8076 {
8077   if (dso_handle_node)
8078     return dso_handle_node;
8079
8080   /* Declare the variable.  */
8081   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8082                                         ptr_type_node);
8083
8084   return dso_handle_node;
8085 }
8086
8087 /* Begin a new function with internal linkage whose job will be simply
8088    to destroy some particular variable.  */
8089
8090 static tree
8091 start_cleanup_fn ()
8092 {
8093   static int counter = 0;
8094   int old_interface_unknown = interface_unknown;
8095   char name[32];
8096   tree parmtypes;
8097   tree fntype;
8098   tree fndecl;
8099
8100   push_to_top_level ();
8101
8102   /* No need to mangle this.  */
8103   push_lang_context (lang_name_c);
8104
8105   interface_unknown = 1;
8106
8107   /* Build the parameter-types.  */
8108   parmtypes = void_list_node;
8109   /* Functions passed to __cxa_atexit take an additional parameter.
8110      We'll just ignore it.  After we implement the new calling
8111      convention for destructors, we can eliminate the use of
8112      additional cleanup functions entirely in the -fnew-abi case.  */
8113   if (flag_use_cxa_atexit)
8114     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8115   /* Build the function type itself.  */
8116   fntype = build_function_type (void_type_node, parmtypes);
8117   /* Build the name of the function.  */
8118   sprintf (name, "__tcf_%d", counter++);
8119   /* Build the function declaration.  */
8120   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8121   /* It's a function with internal linkage, generated by the
8122      compiler.  */
8123   TREE_PUBLIC (fndecl) = 0;
8124   DECL_ARTIFICIAL (fndecl) = 1;
8125   /* Build the parameter.  */
8126   if (flag_use_cxa_atexit)
8127     {
8128       tree parmdecl;
8129
8130       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8131       DECL_CONTEXT (parmdecl) = fndecl;
8132       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8133       TREE_USED (parmdecl) = 1;
8134       DECL_ARGUMENTS (fndecl) = parmdecl;
8135     }
8136
8137   pushdecl (fndecl);
8138   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8139   do_pushlevel ();
8140
8141   interface_unknown = old_interface_unknown;
8142
8143   pop_lang_context ();
8144
8145   return current_function_decl;
8146 }
8147
8148 /* Finish the cleanup function begun by start_cleanup_fn.  */
8149
8150 static void
8151 end_cleanup_fn ()
8152 {
8153   do_poplevel ();
8154
8155   expand_body (finish_function (lineno, 0));
8156
8157   pop_from_top_level ();
8158 }
8159
8160 /* Generate code to handle the destruction of DECL, an object with
8161    static storage duration.  */
8162
8163 void
8164 register_dtor_fn (decl)
8165      tree decl;
8166 {
8167   tree cleanup;
8168   tree compound_stmt;
8169   tree args;
8170   tree fcall;
8171
8172   int saved_flag_access_control;
8173
8174   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8175     return;
8176
8177   /* Call build_cleanup before we enter the anonymous function so that
8178      any access checks will be done relative to the current scope,
8179      rather than the scope of the anonymous function.  */
8180   build_cleanup (decl);
8181
8182   /* Now start the function.  */
8183   cleanup = start_cleanup_fn ();
8184
8185   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8186      to the original function, rather than the anonymous one.  That
8187      will make the back-end think that nested functions are in use,
8188      which causes confusion.  */
8189   saved_flag_access_control = flag_access_control;
8190   flag_access_control = 0;
8191   fcall = build_cleanup (decl);
8192   flag_access_control = saved_flag_access_control;
8193
8194   /* Create the body of the anonymous function.  */
8195   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8196   finish_expr_stmt (fcall);
8197   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8198   end_cleanup_fn ();
8199
8200   /* Call atexit with the cleanup function.  */
8201   mark_addressable (cleanup);
8202   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8203   if (flag_use_cxa_atexit)
8204     {
8205       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8206       args = tree_cons (NULL_TREE, null_pointer_node, args);
8207       args = tree_cons (NULL_TREE, cleanup, args);
8208     }
8209   else
8210     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8211   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8212 }
8213
8214 void
8215 expand_static_init (decl, init)
8216      tree decl;
8217      tree init;
8218 {
8219   tree oldstatic = value_member (decl, static_aggregates);
8220
8221   if (oldstatic)
8222     {
8223       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8224         cp_error ("multiple initializations given for `%D'", decl);
8225     }
8226   else if (! toplevel_bindings_p ())
8227     {
8228       /* Emit code to perform this initialization but once.  */
8229       tree temp;
8230       tree if_stmt;
8231       tree then_clause;
8232       tree assignment;
8233       tree temp_init;
8234
8235       /* Emit code to perform this initialization but once.  This code
8236          looks like:
8237
8238            static int temp = 0;
8239            if (!temp) {
8240              // Do initialization.
8241              temp = 1;
8242              // Register variable for destruction at end of program.
8243            }
8244
8245          Note that the `temp' variable is only set to 1 *after* the
8246          initialization is complete.  This ensures that an exception,
8247          thrown during the construction, will cause the variable to
8248          reinitialized when we pass through this code again, as per:
8249
8250            [stmt.dcl]
8251
8252            If the initialization exits by throwing an exception, the
8253            initialization is not complete, so it will be tried again
8254            the next time control enters the declaration.
8255
8256          In theory, this process should be thread-safe, too; multiple
8257          threads should not be able to initialize the variable more
8258          than once.  We don't yet attempt to ensure thread-safety.  */
8259       temp = get_temp_name (integer_type_node, 1);
8260       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8261
8262       /* Begin the conditional initialization.  */
8263       if_stmt = begin_if_stmt ();
8264       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8265                                             integer_zero_node),
8266                            if_stmt);
8267       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8268
8269       /* Do the initialization itself.  */
8270       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8271           || (init && TREE_CODE (init) == TREE_LIST))
8272         assignment = build_aggr_init (decl, init, 0);
8273       else if (init)
8274         /* The initialization we're doing here is just a bitwise
8275            copy.  */
8276         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8277       else
8278         assignment = NULL_TREE;
8279
8280       /* Once the assignment is complete, set TEMP to 1.  Since the
8281          construction of the static object is complete at this point,
8282          we want to make sure TEMP is set to 1 even if a temporary
8283          constructed during the initialization throws an exception
8284          when it is destroyed.  So, we combine the initialization and
8285          the assignment to TEMP into a single expression, ensuring
8286          that when we call finish_expr_stmt the cleanups will not be
8287          run until after TEMP is set to 1.  */
8288       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8289       if (assignment)
8290         {
8291           assignment = tree_cons (NULL_TREE, assignment,
8292                                   build_tree_list (NULL_TREE,
8293                                                    temp_init));
8294           assignment = build_compound_expr (assignment);
8295         }
8296       else
8297         assignment = temp_init;
8298       finish_expr_stmt (assignment);
8299
8300       /* Use atexit to register a function for destroying this static
8301          variable.  */
8302       register_dtor_fn (decl);
8303
8304       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8305       finish_then_clause (if_stmt);
8306       finish_if_stmt ();
8307     }
8308   else
8309     static_aggregates = tree_cons (init, decl, static_aggregates);
8310 }
8311
8312 /* Finish the declaration of a catch-parameter.  */
8313
8314 tree
8315 start_handler_parms (declspecs, declarator)
8316      tree declspecs;
8317      tree declarator;
8318 {
8319   tree decl;
8320   if (declspecs)
8321     {
8322       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8323                              1, NULL_TREE);
8324       if (decl == NULL_TREE)
8325         error ("invalid catch parameter");
8326     }
8327   else
8328     decl = NULL_TREE;
8329
8330   return decl;
8331 }
8332
8333 \f
8334 /* Make TYPE a complete type based on INITIAL_VALUE.
8335    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8336    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8337
8338 int
8339 complete_array_type (type, initial_value, do_default)
8340      tree type, initial_value;
8341      int do_default;
8342 {
8343   register tree maxindex = NULL_TREE;
8344   int value = 0;
8345
8346   if (initial_value)
8347     {
8348       /* Note MAXINDEX  is really the maximum index,
8349          one less than the size.  */
8350       if (TREE_CODE (initial_value) == STRING_CST)
8351         {
8352           int eltsize
8353             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8354           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8355                                    / eltsize) - 1, 0);
8356         }
8357       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8358         {
8359           tree elts = CONSTRUCTOR_ELTS (initial_value);
8360
8361           maxindex = ssize_int (-1);
8362           for (; elts; elts = TREE_CHAIN (elts))
8363             {
8364               if (TREE_PURPOSE (elts))
8365                 maxindex = TREE_PURPOSE (elts);
8366               else
8367                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8368             }
8369           maxindex = copy_node (maxindex);
8370         }
8371       else
8372         {
8373           /* Make an error message unless that happened already.  */
8374           if (initial_value != error_mark_node)
8375             value = 1;
8376           else
8377             initial_value = NULL_TREE;
8378
8379           /* Prevent further error messages.  */
8380           maxindex = build_int_2 (0, 0);
8381         }
8382     }
8383
8384   if (!maxindex)
8385     {
8386       if (do_default)
8387         maxindex = build_int_2 (0, 0);
8388       value = 2;
8389     }
8390
8391   if (maxindex)
8392     {
8393       tree itype;
8394       tree domain;
8395
8396       domain = build_index_type (maxindex);
8397       TYPE_DOMAIN (type) = domain;
8398
8399       if (! TREE_TYPE (maxindex))
8400         TREE_TYPE (maxindex) = domain;
8401       if (initial_value)
8402         itype = TREE_TYPE (initial_value);
8403       else
8404         itype = NULL;
8405       if (itype && !TYPE_DOMAIN (itype))
8406         TYPE_DOMAIN (itype) = domain;
8407       /* The type of the main variant should never be used for arrays
8408          of different sizes.  It should only ever be completed with the
8409          size of the array.  */
8410       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8411         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8412     }
8413
8414   /* Lay out the type now that we can get the real answer.  */
8415
8416   layout_type (type);
8417
8418   return value;
8419 }
8420 \f
8421 /* Return zero if something is declared to be a member of type
8422    CTYPE when in the context of CUR_TYPE.  STRING is the error
8423    message to print in that case.  Otherwise, quietly return 1.  */
8424
8425 static int
8426 member_function_or_else (ctype, cur_type, flags)
8427      tree ctype, cur_type;
8428      enum overload_flags flags;
8429 {
8430   if (ctype && ctype != cur_type)
8431     {
8432       if (flags == DTOR_FLAG)
8433         error ("destructor for alien class `%s' cannot be a member",
8434                TYPE_NAME_STRING (ctype));
8435       else
8436         error ("constructor for alien class `%s' cannot be a member",
8437                TYPE_NAME_STRING (ctype));
8438       return 0;
8439     }
8440   return 1;
8441 }
8442 \f
8443 /* Subroutine of `grokdeclarator'.  */
8444
8445 /* Generate errors possibly applicable for a given set of specifiers.
8446    This is for ARM $7.1.2.  */
8447
8448 static void
8449 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8450      tree object;
8451      const char *type;
8452      int virtualp, quals, friendp, raises, inlinep;
8453 {
8454   if (virtualp)
8455     cp_error ("`%D' declared as a `virtual' %s", object, type);
8456   if (inlinep)
8457     cp_error ("`%D' declared as an `inline' %s", object, type);
8458   if (quals)
8459     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8460               object, type);
8461   if (friendp)
8462     cp_error_at ("`%D' declared as a friend", object);
8463   if (raises)
8464     cp_error_at ("`%D' declared with an exception specification", object);
8465 }
8466
8467 /* CTYPE is class type, or null if non-class.
8468    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8469    or METHOD_TYPE.
8470    DECLARATOR is the function's name.
8471    VIRTUALP is truthvalue of whether the function is virtual or not.
8472    FLAGS are to be passed through to `grokclassfn'.
8473    QUALS are qualifiers indicating whether the function is `const'
8474    or `volatile'.
8475    RAISES is a list of exceptions that this function can raise.
8476    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8477    not look, and -1 if we should not call `grokclassfn' at all.
8478
8479    Returns `NULL_TREE' if something goes wrong, after issuing
8480    applicable error messages.  */
8481
8482 static tree
8483 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8484             raises, check, friendp, publicp, inlinep, funcdef_flag,
8485             template_count, in_namespace)
8486      tree ctype, type;
8487      tree declarator;
8488      tree orig_declarator;
8489      int virtualp;
8490      enum overload_flags flags;
8491      tree quals, raises;
8492      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8493      tree in_namespace;
8494 {
8495   tree cname, decl;
8496   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8497   int has_default_arg = 0;
8498   tree t;
8499
8500   if (ctype)
8501     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8502       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8503   else
8504     cname = NULL_TREE;
8505
8506   if (raises)
8507     {
8508       type = build_exception_variant (type, raises);
8509     }
8510
8511   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8512   /* Propagate volatile out from type to decl. */
8513   if (TYPE_VOLATILE (type))
8514     TREE_THIS_VOLATILE (decl) = 1;
8515
8516   /* If this decl has namespace scope, set that up.  */
8517   if (in_namespace)
8518     set_decl_namespace (decl, in_namespace, friendp);
8519   else if (publicp && ! ctype)
8520     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8521
8522   /* `main' and builtins have implicit 'C' linkage.  */
8523   if ((MAIN_NAME_P (declarator)
8524        || (IDENTIFIER_LENGTH (declarator) > 10
8525            && IDENTIFIER_POINTER (declarator)[0] == '_'
8526            && IDENTIFIER_POINTER (declarator)[1] == '_'
8527            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8528       && current_lang_name == lang_name_cplusplus
8529       && ctype == NULL_TREE
8530       /* NULL_TREE means global namespace.  */
8531       && DECL_CONTEXT (decl) == NULL_TREE)
8532     DECL_LANGUAGE (decl) = lang_c;
8533
8534   /* Should probably propagate const out from type to decl I bet (mrs).  */
8535   if (staticp)
8536     {
8537       DECL_STATIC_FUNCTION_P (decl) = 1;
8538       DECL_CONTEXT (decl) = ctype;
8539     }
8540
8541   if (ctype)
8542     DECL_CONTEXT (decl) = ctype;
8543
8544   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8545     {
8546       if (processing_template_decl)
8547         error ("cannot declare `::main' to be a template");
8548       if (inlinep)
8549         error ("cannot declare `::main' to be inline");
8550       else if (! publicp)
8551         error ("cannot declare `::main' to be static");
8552       inlinep = 0;
8553       publicp = 1;
8554     }
8555
8556   /* Members of anonymous types and local classes have no linkage; make
8557      them internal.  */
8558   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8559                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8560     publicp = 0;
8561
8562   if (publicp)
8563     {
8564       /* [basic.link]: A name with no linkage (notably, the name of a class
8565          or enumeration declared in a local scope) shall not be used to
8566          declare an entity with linkage.
8567
8568          Only check this for public decls for now.  */
8569       t = no_linkage_check (TREE_TYPE (decl));
8570       if (t)
8571         {
8572           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8573             {
8574               if (DECL_LANGUAGE (decl) == lang_c)
8575                 /* Allow this; it's pretty common in C.  */;
8576               else
8577                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8578                             decl);
8579             }
8580           else
8581             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8582                         decl, t);
8583         }
8584     }
8585
8586   TREE_PUBLIC (decl) = publicp;
8587   if (! publicp)
8588     {
8589       DECL_INTERFACE_KNOWN (decl) = 1;
8590       DECL_NOT_REALLY_EXTERN (decl) = 1;
8591     }
8592
8593   if (inlinep)
8594     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8595
8596   DECL_EXTERNAL (decl) = 1;
8597   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8598     {
8599       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8600                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8601       quals = NULL_TREE;
8602     }
8603
8604   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8605     grok_op_properties (decl, virtualp, check < 0);
8606
8607   if (ctype && decl_function_context (decl))
8608     DECL_NO_STATIC_CHAIN (decl) = 1;
8609
8610   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8611     if (TREE_PURPOSE (t)
8612         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8613       {
8614         has_default_arg = 1;
8615         break;
8616       }
8617
8618   if (friendp
8619       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8620     {
8621       if (funcdef_flag)
8622         cp_error
8623           ("defining explicit specialization `%D' in friend declaration",
8624            orig_declarator);
8625       else
8626         {
8627           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8628             {
8629               /* Something like `template <class T> friend void f<T>()'.  */
8630               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8631                         orig_declarator);
8632               return NULL_TREE;
8633             }
8634
8635
8636           /* A friend declaration of the form friend void f<>().  Record
8637              the information in the TEMPLATE_ID_EXPR.  */
8638           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8639           DECL_TEMPLATE_INFO (decl)
8640             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8641                          TREE_OPERAND (orig_declarator, 1),
8642                          NULL_TREE);
8643
8644           if (has_default_arg)
8645             {
8646               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8647                         decl);
8648               return NULL_TREE;
8649             }
8650
8651           if (inlinep)
8652             {
8653               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8654                         decl);
8655               return NULL_TREE;
8656             }
8657         }
8658     }
8659
8660   if (has_default_arg)
8661     add_defarg_fn (decl);
8662
8663   /* Plain overloading: will not be grok'd by grokclassfn.  */
8664   if (! ctype && ! processing_template_decl
8665       && DECL_LANGUAGE (decl) != lang_c
8666       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8667     set_mangled_name_for_decl (decl);
8668
8669   if (funcdef_flag)
8670     /* Make the init_value nonzero so pushdecl knows this is not
8671        tentative.  error_mark_node is replaced later with the BLOCK.  */
8672     DECL_INITIAL (decl) = error_mark_node;
8673
8674   if (nothrow_libfn_p (decl))
8675     TREE_NOTHROW (decl) = 1;
8676
8677   /* Caller will do the rest of this.  */
8678   if (check < 0)
8679     return decl;
8680
8681   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8682     {
8683       tree tmp;
8684       /* Just handle constructors here.  We could do this
8685          inside the following if stmt, but I think
8686          that the code is more legible by breaking this
8687          case out.  See comments below for what each of
8688          the following calls is supposed to do.  */
8689       DECL_CONSTRUCTOR_P (decl) = 1;
8690
8691       grokclassfn (ctype, decl, flags, quals);
8692
8693       decl = check_explicit_specialization (orig_declarator, decl,
8694                                             template_count,
8695                                             2 * (funcdef_flag != 0) +
8696                                             4 * (friendp != 0));
8697       if (decl == error_mark_node)
8698         return NULL_TREE;
8699
8700       if ((! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8701           && check)
8702         {
8703           tmp = check_classfn (ctype, decl);
8704
8705           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8706             tmp = DECL_TEMPLATE_RESULT(tmp);
8707
8708           if (tmp && DECL_ARTIFICIAL (tmp))
8709             cp_error ("definition of implicitly-declared `%D'", tmp);
8710           if (tmp && duplicate_decls (decl, tmp))
8711             return tmp;
8712         }
8713       if (! grok_ctor_properties (ctype, decl))
8714         return NULL_TREE;
8715     }
8716   else
8717     {
8718       tree tmp;
8719
8720       /* Function gets the ugly name, field gets the nice one.
8721          This call may change the type of the function (because
8722          of default parameters)!  */
8723       if (ctype != NULL_TREE)
8724         grokclassfn (ctype, decl, flags, quals);
8725
8726       decl = check_explicit_specialization (orig_declarator, decl,
8727                                             template_count,
8728                                             2 * (funcdef_flag != 0) +
8729                                             4 * (friendp != 0));
8730       if (decl == error_mark_node)
8731         return NULL_TREE;
8732
8733       if (ctype != NULL_TREE
8734           && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8735           && check)
8736         {
8737           tmp = check_classfn (ctype, decl);
8738
8739           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8740             tmp = DECL_TEMPLATE_RESULT (tmp);
8741
8742           if (tmp && DECL_STATIC_FUNCTION_P (tmp)
8743               && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8744             {
8745               /* Remove the `this' parm added by grokclassfn.
8746                  XXX Isn't this done in start_function, too?  */
8747               revert_static_member_fn (&decl, NULL, NULL);
8748               last_function_parms = TREE_CHAIN (last_function_parms);
8749             }
8750           if (tmp && DECL_ARTIFICIAL (tmp))
8751             cp_error ("definition of implicitly-declared `%D'", tmp);
8752           if (tmp)
8753             {
8754               /* Attempt to merge the declarations.  This can fail, in
8755                  the case of some illegal specialization declarations.  */
8756               if (!duplicate_decls (decl, tmp))
8757                 cp_error ("no `%#D' member function declared in class `%T'",
8758                           decl, ctype);
8759               return tmp;
8760             }
8761         }
8762
8763       if (ctype == NULL_TREE || check)
8764         return decl;
8765
8766       if (virtualp)
8767         {
8768           DECL_VIRTUAL_P (decl) = 1;
8769           if (DECL_VINDEX (decl) == NULL_TREE)
8770             DECL_VINDEX (decl) = error_mark_node;
8771           IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8772         }
8773     }
8774   return decl;
8775 }
8776
8777 static tree
8778 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8779      tree type;
8780      tree declarator;
8781      RID_BIT_TYPE *specbits_in;
8782      int initialized;
8783      int constp;
8784      tree in_namespace;
8785 {
8786   tree decl;
8787   RID_BIT_TYPE specbits;
8788
8789   specbits = *specbits_in;
8790
8791   if (TREE_CODE (type) == OFFSET_TYPE)
8792     {
8793       /* If you declare a static member so that it
8794          can be initialized, the code will reach here.  */
8795       tree basetype = TYPE_OFFSET_BASETYPE (type);
8796       type = TREE_TYPE (type);
8797       decl = build_lang_decl (VAR_DECL, declarator, type);
8798       DECL_CONTEXT (decl) = basetype;
8799       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8800     }
8801   else
8802     {
8803       tree context;
8804
8805       if (in_namespace)
8806         context = in_namespace;
8807       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8808         context = current_namespace;
8809       else
8810         context = NULL_TREE;
8811
8812       if (processing_template_decl)
8813         /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8814            we can call push_template_decl.  */
8815         decl = build_lang_decl (VAR_DECL, declarator, type);
8816       else
8817         decl = build_decl (VAR_DECL, declarator, type);
8818
8819       if (context)
8820         set_decl_namespace (decl, context, 0);
8821
8822       context = DECL_CONTEXT (decl);
8823       if (declarator && context && current_lang_name != lang_name_c)
8824         DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8825     }
8826
8827   if (in_namespace)
8828     set_decl_namespace (decl, in_namespace, 0);
8829
8830   if (RIDBIT_SETP (RID_EXTERN, specbits))
8831     {
8832       DECL_THIS_EXTERN (decl) = 1;
8833       DECL_EXTERNAL (decl) = !initialized;
8834     }
8835
8836   /* In class context, static means one per class,
8837      public access, and static storage.  */
8838   if (DECL_CLASS_SCOPE_P (decl))
8839     {
8840       TREE_PUBLIC (decl) = 1;
8841       TREE_STATIC (decl) = 1;
8842       DECL_EXTERNAL (decl) = 0;
8843     }
8844   /* At top level, either `static' or no s.c. makes a definition
8845      (perhaps tentative), and absence of `static' makes it public.  */
8846   else if (toplevel_bindings_p ())
8847     {
8848       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8849                             && (DECL_THIS_EXTERN (decl) || ! constp));
8850       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8851     }
8852   /* Not at top level, only `static' makes a static definition.  */
8853   else
8854     {
8855       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8856       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8857     }
8858
8859   if (TREE_PUBLIC (decl))
8860     {
8861       /* [basic.link]: A name with no linkage (notably, the name of a class
8862          or enumeration declared in a local scope) shall not be used to
8863          declare an entity with linkage.
8864
8865          Only check this for public decls for now.  */
8866       tree t = no_linkage_check (TREE_TYPE (decl));
8867       if (t)
8868         {
8869           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8870             /* Ignore for now; `enum { foo } e' is pretty common.  */;
8871           else
8872             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8873                         decl, t);
8874         }
8875     }
8876
8877   return decl;
8878 }
8879
8880 /* Create and return a canonical pointer to member function type, for
8881    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
8882
8883 tree
8884 build_ptrmemfunc_type (type)
8885      tree type;
8886 {
8887   tree fields[4];
8888   tree t;
8889   tree u;
8890   tree unqualified_variant = NULL_TREE;
8891
8892   /* If a canonical type already exists for this type, use it.  We use
8893      this method instead of type_hash_canon, because it only does a
8894      simple equality check on the list of field members.  */
8895
8896   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8897     return t;
8898
8899   /* Make sure that we always have the unqualified pointer-to-member
8900      type first.  */
8901   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8902     unqualified_variant
8903       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
8904
8905   t = make_aggr_type (RECORD_TYPE);
8906   /* Let the front-end know this is a pointer to member function...  */
8907   TYPE_PTRMEMFUNC_FLAG (t) = 1;
8908   /* ... and not really an aggregate.  */
8909   SET_IS_AGGR_TYPE (t, 0);
8910
8911   if (!flag_new_abi)
8912     {
8913       u = make_aggr_type (UNION_TYPE);
8914       SET_IS_AGGR_TYPE (u, 0);
8915       fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
8916       fields[1] = build_lang_decl (FIELD_DECL, delta2_identifier,
8917                                    delta_type_node);
8918       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
8919       TYPE_NAME (u) = NULL_TREE;
8920
8921       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
8922                                    delta_type_node);
8923       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
8924                                    delta_type_node);
8925       fields[2] = build_lang_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
8926       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
8927     }
8928   else
8929     {
8930       fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
8931       fields[1] = build_lang_decl (FIELD_DECL, delta_identifier,
8932                                    delta_type_node);
8933       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
8934     }
8935
8936   /* Zap out the name so that the back-end will give us the debugging
8937      information for this anonymous RECORD_TYPE.  */
8938   TYPE_NAME (t) = NULL_TREE;
8939
8940   /* If this is not the unqualified form of this pointer-to-member
8941      type, set the TYPE_MAIN_VARIANT for this type to be the
8942      unqualified type.  Since they are actually RECORD_TYPEs that are
8943      not variants of each other, we must do this manually.  */
8944   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8945     {
8946       t = build_qualified_type (t, CP_TYPE_QUALS (type));
8947       TYPE_MAIN_VARIANT (t) = unqualified_variant;
8948       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
8949       TYPE_NEXT_VARIANT (unqualified_variant) = t;
8950     }
8951
8952   /* Cache this pointer-to-member type so that we can find it again
8953      later.  */
8954   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
8955
8956   /* Seems to be wanted.  */
8957   CLASSTYPE_GOT_SEMICOLON (t) = 1;
8958
8959   return t;
8960 }
8961
8962 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8963    Check to see that the definition is valid.  Issue appropriate error
8964    messages.  Return 1 if the definition is particularly bad, or 0
8965    otherwise.  */
8966
8967 int
8968 check_static_variable_definition (decl, type)
8969      tree decl;
8970      tree type;
8971 {
8972   /* Motion 10 at San Diego: If a static const integral data member is
8973      initialized with an integral constant expression, the initializer
8974      may appear either in the declaration (within the class), or in
8975      the definition, but not both.  If it appears in the class, the
8976      member is a member constant.  The file-scope definition is always
8977      required.  */
8978   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
8979     {
8980       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
8981                 type);
8982       /* If we just return the declaration, crashes will sometimes
8983          occur.  We therefore return void_type_node, as if this was a
8984          friend declaration, to cause callers to completely ignore
8985          this declaration.  */
8986       return 1;
8987     }
8988   else if (!CP_TYPE_CONST_P (type))
8989     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
8990               decl);
8991   else if (pedantic && !INTEGRAL_TYPE_P (type))
8992     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
8993
8994   return 0;
8995 }
8996
8997 /* Given the SIZE (i.e., number of elements) in an array, compute an
8998    appropriate index type for the array.  If non-NULL, NAME is the
8999    name of the thing being declared.  */
9000
9001 tree
9002 compute_array_index_type (name, size)
9003      tree name;
9004      tree size;
9005 {
9006   tree itype;
9007
9008   /* The size might be the result of a cast. */
9009   STRIP_TYPE_NOPS (size);
9010
9011   /* It might be a const variable or enumeration constant.  */
9012   if (TREE_READONLY_DECL_P (size))
9013     size = decl_constant_value (size);
9014
9015   /* If this involves a template parameter, it will be a constant at
9016      instantiation time, but we don't know what the value is yet.
9017      Even if no template parameters are involved, we may an expression
9018      that is not a constant; we don't even simplify `1 + 2' when
9019      processing a template.  */
9020   if (processing_template_decl)
9021     {
9022       /* Resolve a qualified reference to an enumerator or static
9023          const data member of ours.  */
9024       if (TREE_CODE (size) == SCOPE_REF
9025           && TREE_OPERAND (size, 0) == current_class_type)
9026         {
9027           tree t = lookup_field (current_class_type,
9028                                  TREE_OPERAND (size, 1), 0, 0);
9029           if (t)
9030             size = t;
9031         }
9032
9033       return build_index_type (build_min (MINUS_EXPR, sizetype,
9034                                           size, integer_one_node));
9035     }
9036
9037   /* The array bound must be an integer type.  */
9038   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9039       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9040       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9041     {
9042       if (name)
9043         cp_error ("size of array `%D' has non-integer type", name);
9044       else
9045         cp_error ("size of array has non-integer type");
9046       size = integer_one_node;
9047     }
9048
9049   /* Normally, the array-bound will be a constant.  */
9050   if (TREE_CONSTANT (size))
9051     {
9052       /* Check to see if the array bound overflowed.  Make that an
9053          error, no matter how generous we're being.  */
9054       int old_flag_pedantic_errors = flag_pedantic_errors;
9055       int old_pedantic = pedantic;
9056       pedantic = flag_pedantic_errors = 1;
9057       constant_expression_warning (size);
9058       pedantic = old_pedantic;
9059       flag_pedantic_errors = old_flag_pedantic_errors;
9060
9061       /* An array must have a positive number of elements.  */
9062       if (INT_CST_LT (size, integer_zero_node))
9063         {
9064           if (name)
9065             cp_error ("size of array `%D' is negative", name);
9066           else
9067             cp_error ("size of array is negative");
9068           size = integer_one_node;
9069         }
9070       /* Except that an extension we allow zero-sized arrays.  We
9071          always allow them in system headers because glibc uses
9072          them.  */
9073       else if (integer_zerop (size) && pedantic && !in_system_header)
9074         {
9075           if (name)
9076             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9077           else
9078             cp_pedwarn ("ISO C++ forbids zero-size array");
9079         }
9080     }
9081
9082   /* Compute the index of the largest element in the array.  It is
9083      one less than the number of elements in the array.  */
9084   itype
9085     = fold (build_binary_op (MINUS_EXPR,
9086                              cp_convert (ssizetype, size),
9087                              cp_convert (ssizetype,
9088                                          integer_one_node)));
9089
9090   /* Check for variable-sized arrays.  We allow such things as an
9091      extension, even though they are not allowed in ANSI/ISO C++.  */
9092   if (!TREE_CONSTANT (itype))
9093     {
9094       if (pedantic)
9095         {
9096           if (name)
9097             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9098                         name);
9099           else
9100             cp_pedwarn ("ISO C++ forbids variable-size array");
9101         }
9102
9103       /* Create a variable-sized array index type.  */
9104       itype = variable_size (itype);
9105     }
9106   /* Make sure that there was no overflow when creating to a signed
9107      index type.  (For example, on a 32-bit machine, an array with
9108      size 2^32 - 1 is too big.)  */
9109   else if (TREE_OVERFLOW (itype))
9110     {
9111       error ("overflow in array dimension");
9112       TREE_OVERFLOW (itype) = 0;
9113     }
9114
9115   /* Create and return the appropriate index type.  */
9116   return build_index_type (itype);
9117 }
9118
9119 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9120    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9121    with this type.  */
9122
9123 static tree
9124 create_array_type_for_decl (name, type, size)
9125      tree name;
9126      tree type;
9127      tree size;
9128 {
9129   tree itype = NULL_TREE;
9130   const char* error_msg;
9131
9132   /* If things have already gone awry, bail now.  */
9133   if (type == error_mark_node || size == error_mark_node)
9134     return error_mark_node;
9135
9136   /* Assume that everything will go OK.  */
9137   error_msg = NULL;
9138
9139   /* There are some types which cannot be array elements.  */
9140   switch (TREE_CODE (type))
9141     {
9142     case VOID_TYPE:
9143       error_msg = "array of void";
9144       break;
9145
9146     case FUNCTION_TYPE:
9147       error_msg = "array of functions";
9148       break;
9149
9150     case REFERENCE_TYPE:
9151       error_msg = "array of references";
9152       break;
9153
9154     case OFFSET_TYPE:
9155       error_msg = "array of data members";
9156       break;
9157
9158     case METHOD_TYPE:
9159       error_msg = "array of function members";
9160       break;
9161
9162     default:
9163       break;
9164     }
9165
9166   /* If something went wrong, issue an error-message and return.  */
9167   if (error_msg)
9168     {
9169       if (name)
9170         cp_error ("declaration of `%D' as %s", name, error_msg);
9171       else
9172         cp_error ("creating %s", error_msg);
9173
9174       return error_mark_node;
9175     }
9176
9177   /* [dcl.array]
9178
9179      The constant expressions that specify the bounds of the arrays
9180      can be omitted only for the first member of the sequence.  */
9181   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9182     {
9183       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9184                 name);
9185
9186       return error_mark_node;
9187     }
9188
9189   /* Figure out the index type for the array.  */
9190   if (size)
9191     itype = compute_array_index_type (name, size);
9192
9193   return build_cplus_array_type (type, itype);
9194 }
9195
9196 /* Given declspecs and a declarator,
9197    determine the name and type of the object declared
9198    and construct a ..._DECL node for it.
9199    (In one case we can return a ..._TYPE node instead.
9200     For invalid input we sometimes return 0.)
9201
9202    DECLSPECS is a chain of tree_list nodes whose value fields
9203     are the storage classes and type specifiers.
9204
9205    DECL_CONTEXT says which syntactic context this declaration is in:
9206      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9207      FUNCDEF for a function definition.  Like NORMAL but a few different
9208       error messages in each case.  Return value may be zero meaning
9209       this definition is too screwy to try to parse.
9210      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9211       handle member functions (which have FIELD context).
9212       Return value may be zero meaning this definition is too screwy to
9213       try to parse.
9214      PARM for a parameter declaration (either within a function prototype
9215       or before a function body).  Make a PARM_DECL, or return void_type_node.
9216      CATCHPARM for a parameter declaration before a catch clause.
9217      TYPENAME if for a typename (in a cast or sizeof).
9218       Don't make a DECL node; just return the ..._TYPE node.
9219      FIELD for a struct or union field; make a FIELD_DECL.
9220      BITFIELD for a field with specified width.
9221    INITIALIZED is 1 if the decl has an initializer.
9222
9223    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9224    normal attributes in TREE_PURPOSE, or NULL_TREE.
9225
9226    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9227    It may also be so in the PARM case, for a prototype where the
9228    argument type is specified but not the name.
9229
9230    This function is where the complicated C meanings of `static'
9231    and `extern' are interpreted.
9232
9233    For C++, if there is any monkey business to do, the function which
9234    calls this one must do it, i.e., prepending instance variables,
9235    renaming overloaded function names, etc.
9236
9237    Note that for this C++, it is an error to define a method within a class
9238    which does not belong to that class.
9239
9240    Except in the case where SCOPE_REFs are implicitly known (such as
9241    methods within a class being redundantly qualified),
9242    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9243    (class_name::decl_name).  The caller must also deal with this.
9244
9245    If a constructor or destructor is seen, and the context is FIELD,
9246    then the type gains the attribute TREE_HAS_x.  If such a declaration
9247    is erroneous, NULL_TREE is returned.
9248
9249    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9250    function, these are the qualifiers to give to the `this' pointer. We
9251    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9252
9253    May return void_type_node if the declarator turned out to be a friend.
9254    See grokfield for details.  */
9255
9256 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
9257
9258 tree
9259 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9260      tree declspecs;
9261      tree declarator;
9262      enum decl_context decl_context;
9263      int initialized;
9264      tree attrlist;
9265 {
9266   RID_BIT_TYPE specbits;
9267   int nclasses = 0;
9268   tree spec;
9269   tree type = NULL_TREE;
9270   int longlong = 0;
9271   int constp;
9272   int restrictp;
9273   int volatilep;
9274   int type_quals;
9275   int virtualp, explicitp, friendp, inlinep, staticp;
9276   int explicit_int = 0;
9277   int explicit_char = 0;
9278   int defaulted_int = 0;
9279   tree typedef_decl = NULL_TREE;
9280   const char *name;
9281   tree typedef_type = NULL_TREE;
9282   int funcdef_flag = 0;
9283   enum tree_code innermost_code = ERROR_MARK;
9284   int bitfield = 0;
9285 #if 0
9286   /* See the code below that used this.  */
9287   tree decl_machine_attr = NULL_TREE;
9288 #endif
9289   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9290      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9291   tree init = NULL_TREE;
9292
9293   /* Keep track of what sort of function is being processed
9294      so that we can warn about default return values, or explicit
9295      return values which do not match prescribed defaults.  */
9296   enum return_types return_type = return_normal;
9297
9298   tree dname = NULL_TREE;
9299   tree ctype = current_class_type;
9300   tree ctor_return_type = NULL_TREE;
9301   enum overload_flags flags = NO_SPECIAL;
9302   tree quals = NULL_TREE;
9303   tree raises = NULL_TREE;
9304   int template_count = 0;
9305   tree in_namespace = NULL_TREE;
9306   tree inner_attrs;
9307   int ignore_attrs;
9308
9309   RIDBIT_RESET_ALL (specbits);
9310   if (decl_context == FUNCDEF)
9311     funcdef_flag = 1, decl_context = NORMAL;
9312   else if (decl_context == MEMFUNCDEF)
9313     funcdef_flag = -1, decl_context = FIELD;
9314   else if (decl_context == BITFIELD)
9315     bitfield = 1, decl_context = FIELD;
9316
9317   /* Look inside a declarator for the name being declared
9318      and get it as a string, for an error message.  */
9319   {
9320     tree *next = &declarator;
9321     register tree decl;
9322     name = NULL;
9323
9324     while (next && *next)
9325       {
9326         decl = *next;
9327         switch (TREE_CODE (decl))
9328           {
9329           case TREE_LIST:
9330             /* For attributes.  */
9331             next = &TREE_VALUE (decl);
9332             break;
9333
9334           case COND_EXPR:
9335             ctype = NULL_TREE;
9336             next = &TREE_OPERAND (decl, 0);
9337             break;
9338
9339           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9340             {
9341               tree name = TREE_OPERAND (decl, 0);
9342               tree rename = NULL_TREE;
9343
9344               my_friendly_assert (flags == NO_SPECIAL, 152);
9345               flags = DTOR_FLAG;
9346               return_type = return_dtor;
9347               if (TREE_CODE (name) == TYPE_DECL)
9348                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9349               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9350               if (ctype == NULL_TREE)
9351                 {
9352                   if (current_class_type == NULL_TREE)
9353                     {
9354                       error ("destructors must be member functions");
9355                       flags = NO_SPECIAL;
9356                     }
9357                   else
9358                     {
9359                       tree t = constructor_name (current_class_name);
9360                       if (t != name)
9361                         rename = t;
9362                     }
9363                 }
9364               else
9365                 {
9366                   tree t = constructor_name (ctype);
9367                   if (t != name)
9368                     rename = t;
9369                 }
9370
9371               if (rename)
9372                 {
9373                   cp_error ("destructor `%T' must match class name `%T'",
9374                             name, rename);
9375                   TREE_OPERAND (decl, 0) = rename;
9376                 }
9377               next = &name;
9378             }
9379             break;
9380
9381           case ADDR_EXPR:       /* C++ reference declaration */
9382             /* Fall through. */
9383           case ARRAY_REF:
9384           case INDIRECT_REF:
9385             ctype = NULL_TREE;
9386             innermost_code = TREE_CODE (decl);
9387             next = &TREE_OPERAND (decl, 0);
9388             break;
9389
9390           case CALL_EXPR:
9391             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9392               {
9393                 /* This is actually a variable declaration using
9394                    constructor syntax.  We need to call start_decl and
9395                    cp_finish_decl so we can get the variable
9396                    initialized...  */
9397
9398                 tree attributes, prefix_attributes;
9399
9400                 *next = TREE_OPERAND (decl, 0);
9401                 init = CALL_DECLARATOR_PARMS (decl);
9402
9403                 if (attrlist)
9404                   {
9405                     attributes = TREE_PURPOSE (attrlist);
9406                     prefix_attributes = TREE_VALUE (attrlist);
9407                   }
9408                 else
9409                   {
9410                     attributes = NULL_TREE;
9411                     prefix_attributes = NULL_TREE;
9412                   }
9413
9414                 decl = start_decl (declarator, declspecs, 1,
9415                                    attributes, prefix_attributes);
9416                 decl_type_access_control (decl);
9417                 if (decl)
9418                   {
9419                     /* Look for __unused__ attribute */
9420                     if (TREE_USED (TREE_TYPE (decl)))
9421                       TREE_USED (decl) = 1;
9422                     finish_decl (decl, init, NULL_TREE);
9423                   }
9424                 else
9425                   cp_error ("invalid declarator");
9426                 return 0;
9427               }
9428             innermost_code = TREE_CODE (decl);
9429             if (decl_context == FIELD && ctype == NULL_TREE)
9430               ctype = current_class_type;
9431             if (ctype
9432                 && TREE_OPERAND (decl, 0)
9433                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9434                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9435                          == constructor_name_full (ctype))
9436                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9437                             == constructor_name (ctype)))))
9438               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9439             next = &TREE_OPERAND (decl, 0);
9440             decl = *next;
9441             if (ctype != NULL_TREE
9442                 && decl != NULL_TREE && flags != DTOR_FLAG
9443                 && decl == constructor_name (ctype))
9444               {
9445                 return_type = return_ctor;
9446                 ctor_return_type = ctype;
9447               }
9448             ctype = NULL_TREE;
9449             break;
9450
9451           case TEMPLATE_ID_EXPR:
9452               {
9453                 tree fns = TREE_OPERAND (decl, 0);
9454
9455                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9456                   fns = TREE_OPERAND (fns, 0);
9457
9458                 dname = fns;
9459                 if (TREE_CODE (dname) == COMPONENT_REF)
9460                   dname = TREE_OPERAND (dname, 1);
9461                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9462                   {
9463                     my_friendly_assert (is_overloaded_fn (dname),
9464                                         19990331);
9465                     dname = DECL_NAME (get_first_fn (dname));
9466                   }
9467               }
9468           /* Fall through. */
9469
9470           case IDENTIFIER_NODE:
9471             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9472               dname = decl;
9473
9474             next = 0;
9475
9476             if (is_rid (dname))
9477               {
9478                 cp_error ("declarator-id missing; using reserved word `%D'",
9479                           dname);
9480                 name = IDENTIFIER_POINTER (dname);
9481               }
9482             if (! IDENTIFIER_OPNAME_P (dname)
9483                 /* GNU/Linux headers use '__op'.  Arrgh.  */
9484                 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
9485               name = IDENTIFIER_POINTER (dname);
9486             else
9487               {
9488                 if (IDENTIFIER_TYPENAME_P (dname))
9489                   {
9490                     my_friendly_assert (flags == NO_SPECIAL, 154);
9491                     flags = TYPENAME_FLAG;
9492                     ctor_return_type = TREE_TYPE (dname);
9493                     return_type = return_conversion;
9494                   }
9495                 name = operator_name_string (dname);
9496               }
9497             break;
9498
9499             /* C++ extension */
9500           case SCOPE_REF:
9501             {
9502               /* Perform error checking, and decide on a ctype.  */
9503               tree cname = TREE_OPERAND (decl, 0);
9504               if (cname == NULL_TREE)
9505                 ctype = NULL_TREE;
9506               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9507                 {
9508                   ctype = NULL_TREE;
9509                   in_namespace = TREE_OPERAND (decl, 0);
9510                   TREE_OPERAND (decl, 0) = NULL_TREE;
9511                 }
9512               else if (! is_aggr_type (cname, 1))
9513                 TREE_OPERAND (decl, 0) = NULL_TREE;
9514               /* Must test TREE_OPERAND (decl, 1), in case user gives
9515                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9516               else if (TREE_OPERAND (decl, 1)
9517                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9518                 ctype = cname;
9519               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9520                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9521                 {
9522                   cp_error ("`%T::%D' is not a valid declarator", cname,
9523                             TREE_OPERAND (decl, 1));
9524                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9525                             cname, TREE_OPERAND (decl, 1));
9526                   return void_type_node;
9527                 }
9528               else if (ctype == NULL_TREE)
9529                 ctype = cname;
9530               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9531                 TREE_OPERAND (decl, 0) = ctype;
9532               else
9533                 {
9534                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9535                     {
9536                       cp_error ("type `%T' is not derived from type `%T'",
9537                                 cname, ctype);
9538                       TREE_OPERAND (decl, 0) = NULL_TREE;
9539                     }
9540                   else
9541                     ctype = cname;
9542                 }
9543
9544               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9545                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9546                        == constructor_name_full (ctype))
9547                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9548                           == constructor_name (ctype))))
9549                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9550               next = &TREE_OPERAND (decl, 1);
9551               decl = *next;
9552               if (ctype)
9553                 {
9554                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9555                       && constructor_name (ctype) == decl)
9556                     {
9557                       return_type = return_ctor;
9558                       ctor_return_type = ctype;
9559                     }
9560                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9561                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9562                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9563                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9564                     {
9565                       return_type = return_dtor;
9566                       ctor_return_type = ctype;
9567                       flags = DTOR_FLAG;
9568                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9569                       next = &TREE_OPERAND (decl, 0);
9570                     }
9571                 }
9572             }
9573             break;
9574
9575           case ERROR_MARK:
9576             next = 0;
9577             break;
9578
9579           case TYPE_DECL:
9580             /* Parse error puts this typespec where
9581                a declarator should go.  */
9582             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9583             if (TREE_TYPE (decl) == current_class_type)
9584               cp_error ("  perhaps you want `%T' for a constructor",
9585                         current_class_name);
9586             dname = DECL_NAME (decl);
9587             name = IDENTIFIER_POINTER (dname);
9588
9589             /* Avoid giving two errors for this.  */
9590             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9591
9592             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9593             *next = dname;
9594             next = 0;
9595             break;
9596
9597           default:
9598             cp_compiler_error ("`%D' as declarator", decl);
9599             return 0; /* We used to do a 155 abort here.  */
9600           }
9601       }
9602   }
9603
9604   /* A function definition's declarator must have the form of
9605      a function declarator.  */
9606
9607   if (funcdef_flag && innermost_code != CALL_EXPR)
9608     return 0;
9609
9610   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9611       && innermost_code != CALL_EXPR
9612       && ! (ctype && declspecs == NULL_TREE))
9613     {
9614       cp_error ("declaration of `%D' as non-function", dname);
9615       return void_type_node;
9616     }
9617
9618   /* Anything declared one level down from the top level
9619      must be one of the parameters of a function
9620      (because the body is at least two levels down).  */
9621
9622   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9623      by not allowing C++ class definitions to specify their parameters
9624      with xdecls (must be spec.d in the parmlist).
9625
9626      Since we now wait to push a class scope until we are sure that
9627      we are in a legitimate method context, we must set oldcname
9628      explicitly (since current_class_name is not yet alive).
9629
9630      We also want to avoid calling this a PARM if it is in a namespace.  */
9631
9632   if (decl_context == NORMAL && !toplevel_bindings_p ())
9633     {
9634       struct binding_level *b = current_binding_level;
9635       current_binding_level = b->level_chain;
9636       if (current_binding_level != 0 && toplevel_bindings_p ())
9637         decl_context = PARM;
9638       current_binding_level = b;
9639     }
9640
9641   if (name == NULL)
9642     name = decl_context == PARM ? "parameter" : "type name";
9643
9644   /* Look through the decl specs and record which ones appear.
9645      Some typespecs are defined as built-in typenames.
9646      Others, the ones that are modifiers of other types,
9647      are represented by bits in SPECBITS: set the bits for
9648      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9649
9650      If there is a typedef name or a type, store the type in TYPE.
9651      This includes builtin typedefs such as `int'.
9652
9653      Set EXPLICIT_INT if the type is `int' or `char' and did not
9654      come from a user typedef.
9655
9656      Set LONGLONG if `long' is mentioned twice.
9657
9658      For C++, constructors and destructors have their own fast treatment.  */
9659
9660   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9661     {
9662       register int i;
9663       register tree id;
9664
9665       /* Certain parse errors slip through.  For example,
9666          `int class;' is not caught by the parser. Try
9667          weakly to recover here.  */
9668       if (TREE_CODE (spec) != TREE_LIST)
9669         return 0;
9670
9671       id = TREE_VALUE (spec);
9672
9673       if (TREE_CODE (id) == IDENTIFIER_NODE)
9674         {
9675           if (id == ridpointers[(int) RID_INT]
9676               || id == ridpointers[(int) RID_CHAR]
9677               || id == ridpointers[(int) RID_BOOL]
9678               || id == ridpointers[(int) RID_WCHAR])
9679             {
9680               if (type)
9681                 {
9682                   if (id == ridpointers[(int) RID_BOOL])
9683                     error ("`bool' is now a keyword");
9684                   else
9685                     cp_error ("extraneous `%T' ignored", id);
9686                 }
9687               else
9688                 {
9689                   if (id == ridpointers[(int) RID_INT])
9690                     explicit_int = 1;
9691                   else if (id == ridpointers[(int) RID_CHAR])
9692                     explicit_char = 1;
9693                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9694                 }
9695               goto found;
9696             }
9697           /* C++ aggregate types.  */
9698           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9699             {
9700               if (type)
9701                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9702               else
9703                 type = IDENTIFIER_TYPE_VALUE (id);
9704               goto found;
9705             }
9706
9707           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9708             {
9709               if (ridpointers[i] == id)
9710                 {
9711                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9712                     {
9713                       if (pedantic && ! in_system_header && warn_long_long)
9714                         pedwarn ("ISO C++ does not support `long long'");
9715                       if (longlong)
9716                         error ("`long long long' is too long for GCC");
9717                       else
9718                         longlong = 1;
9719                     }
9720                   else if (RIDBIT_SETP (i, specbits))
9721                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9722                   RIDBIT_SET (i, specbits);
9723                   goto found;
9724                 }
9725             }
9726         }
9727       /* C++ aggregate types.  */
9728       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9729         {
9730           if (type)
9731             cp_error ("multiple declarations `%T' and `%T'", type,
9732                       TREE_TYPE (id));
9733           else
9734             {
9735               type = TREE_TYPE (id);
9736               TREE_VALUE (spec) = type;
9737             }
9738           goto found;
9739         }
9740       if (type)
9741         error ("two or more data types in declaration of `%s'", name);
9742       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9743         {
9744           register tree t = lookup_name (id, 1);
9745           if (!t || TREE_CODE (t) != TYPE_DECL)
9746             error ("`%s' fails to be a typedef or built in type",
9747                    IDENTIFIER_POINTER (id));
9748           else
9749             {
9750               type = TREE_TYPE (t);
9751 #if 0
9752               /* See the code below that used this.  */
9753               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9754 #endif
9755               typedef_decl = t;
9756             }
9757         }
9758       else if (id != error_mark_node)
9759         /* Can't change CLASS nodes into RECORD nodes here!  */
9760         type = id;
9761
9762     found: ;
9763     }
9764
9765   typedef_type = type;
9766
9767   /* No type at all: default to `int', and set DEFAULTED_INT
9768      because it was not a user-defined typedef.  */
9769
9770   if (type == NULL_TREE
9771       && (RIDBIT_SETP (RID_SIGNED, specbits)
9772           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9773           || RIDBIT_SETP (RID_LONG, specbits)
9774           || RIDBIT_SETP (RID_SHORT, specbits)))
9775     {
9776       /* These imply 'int'.  */
9777       type = integer_type_node;
9778       defaulted_int = 1;
9779     }
9780
9781   if (type == NULL_TREE)
9782     {
9783       explicit_int = -1;
9784       if (return_type == return_dtor)
9785         type = void_type_node;
9786       else if (return_type == return_ctor)
9787         type = build_pointer_type (ctor_return_type);
9788       else if (return_type == return_conversion)
9789         type = ctor_return_type;
9790       else
9791         {
9792           /* We handle `main' specially here, because 'main () { }' is so
9793              common.  With no options, it is allowed.  With -Wreturn-type,
9794              it is a warning.  It is only an error with -pedantic-errors.  */
9795           int is_main = (funcdef_flag
9796                          && MAIN_NAME_P (dname)
9797                          && ctype == NULL_TREE
9798                          && in_namespace == NULL_TREE
9799                          && current_namespace == global_namespace);
9800
9801           if (in_system_header || flag_ms_extensions)
9802             /* Allow it, sigh.  */;
9803           else if (pedantic || ! is_main)
9804             cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
9805                         name);
9806           else if (warn_return_type)
9807             cp_warning ("ISO C++ forbids declaration of `%s' with no type",
9808                         name);
9809
9810           type = integer_type_node;
9811         }
9812     }
9813   else if (return_type == return_dtor)
9814     {
9815       error ("return type specification for destructor invalid");
9816       type = void_type_node;
9817     }
9818   else if (return_type == return_ctor)
9819     {
9820       error ("return type specification for constructor invalid");
9821       type = build_pointer_type (ctor_return_type);
9822     }
9823   else if (return_type == return_conversion)
9824     {
9825       if (!same_type_p (type, ctor_return_type))
9826         cp_error ("operator `%T' declared to return `%T'",
9827                   ctor_return_type, type);
9828       else
9829         cp_pedwarn ("return type specified for `operator %T'",
9830                     ctor_return_type);
9831
9832       type = ctor_return_type;
9833     }
9834
9835   ctype = NULL_TREE;
9836
9837   /* Now process the modifiers that were specified
9838      and check for invalid combinations.  */
9839
9840   /* Long double is a special combination.  */
9841
9842   if (RIDBIT_SETP (RID_LONG, specbits)
9843       && TYPE_MAIN_VARIANT (type) == double_type_node)
9844     {
9845       RIDBIT_RESET (RID_LONG, specbits);
9846       type = build_qualified_type (long_double_type_node,
9847                                    CP_TYPE_QUALS (type));
9848     }
9849
9850   /* Check all other uses of type modifiers.  */
9851
9852   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9853       || RIDBIT_SETP (RID_SIGNED, specbits)
9854       || RIDBIT_SETP (RID_LONG, specbits)
9855       || RIDBIT_SETP (RID_SHORT, specbits))
9856     {
9857       int ok = 0;
9858
9859       if (TREE_CODE (type) == REAL_TYPE)
9860         error ("short, signed or unsigned invalid for `%s'", name);
9861       else if (TREE_CODE (type) != INTEGER_TYPE)
9862         error ("long, short, signed or unsigned invalid for `%s'", name);
9863       else if (RIDBIT_SETP (RID_LONG, specbits)
9864                && RIDBIT_SETP (RID_SHORT, specbits))
9865         error ("long and short specified together for `%s'", name);
9866       else if ((RIDBIT_SETP (RID_LONG, specbits)
9867                 || RIDBIT_SETP (RID_SHORT, specbits))
9868                && explicit_char)
9869         error ("long or short specified with char for `%s'", name);
9870       else if ((RIDBIT_SETP (RID_LONG, specbits)
9871                 || RIDBIT_SETP (RID_SHORT, specbits))
9872                && TREE_CODE (type) == REAL_TYPE)
9873         error ("long or short specified with floating type for `%s'", name);
9874       else if (RIDBIT_SETP (RID_SIGNED, specbits)
9875                && RIDBIT_SETP (RID_UNSIGNED, specbits))
9876         error ("signed and unsigned given together for `%s'", name);
9877       else
9878         {
9879           ok = 1;
9880           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
9881             {
9882               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9883                        name);
9884               if (flag_pedantic_errors)
9885                 ok = 0;
9886             }
9887         }
9888
9889       /* Discard the type modifiers if they are invalid.  */
9890       if (! ok)
9891         {
9892           RIDBIT_RESET (RID_UNSIGNED, specbits);
9893           RIDBIT_RESET (RID_SIGNED, specbits);
9894           RIDBIT_RESET (RID_LONG, specbits);
9895           RIDBIT_RESET (RID_SHORT, specbits);
9896           longlong = 0;
9897         }
9898     }
9899
9900   if (RIDBIT_SETP (RID_COMPLEX, specbits)
9901       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9902     {
9903       error ("complex invalid for `%s'", name);
9904       RIDBIT_RESET (RID_COMPLEX, specbits);
9905     }
9906
9907   /* Decide whether an integer type is signed or not.
9908      Optionally treat bitfields as signed by default.  */
9909   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9910       /* [class.bit]
9911
9912          It is implementation-defined whether a plain (neither
9913          explicitly signed or unsigned) char, short, int, or long
9914          bit-field is signed or unsigned.
9915
9916          Naturally, we extend this to long long as well.  Note that
9917          this does not include wchar_t.  */
9918       || (bitfield && !flag_signed_bitfields
9919           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
9920           /* A typedef for plain `int' without `signed' can be
9921              controlled just like plain `int', but a typedef for
9922              `signed int' cannot be so controlled.  */
9923           && !(typedef_decl
9924                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
9925           && (TREE_CODE (type) == INTEGER_TYPE
9926               || TREE_CODE (type) == CHAR_TYPE)
9927           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
9928     {
9929       if (longlong)
9930         type = long_long_unsigned_type_node;
9931       else if (RIDBIT_SETP (RID_LONG, specbits))
9932         type = long_unsigned_type_node;
9933       else if (RIDBIT_SETP (RID_SHORT, specbits))
9934         type = short_unsigned_type_node;
9935       else if (type == char_type_node)
9936         type = unsigned_char_type_node;
9937       else if (typedef_decl)
9938         type = unsigned_type (type);
9939       else
9940         type = unsigned_type_node;
9941     }
9942   else if (RIDBIT_SETP (RID_SIGNED, specbits)
9943            && type == char_type_node)
9944     type = signed_char_type_node;
9945   else if (longlong)
9946     type = long_long_integer_type_node;
9947   else if (RIDBIT_SETP (RID_LONG, specbits))
9948     type = long_integer_type_node;
9949   else if (RIDBIT_SETP (RID_SHORT, specbits))
9950     type = short_integer_type_node;
9951
9952   if (RIDBIT_SETP (RID_COMPLEX, specbits))
9953     {
9954       /* If we just have "complex", it is equivalent to
9955          "complex double", but if any modifiers at all are specified it is
9956          the complex form of TYPE.  E.g, "complex short" is
9957          "complex short int".  */
9958
9959       if (defaulted_int && ! longlong
9960           && ! (RIDBIT_SETP (RID_LONG, specbits)
9961                 || RIDBIT_SETP (RID_SHORT, specbits)
9962                 || RIDBIT_SETP (RID_SIGNED, specbits)
9963                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
9964         type = complex_double_type_node;
9965       else if (type == integer_type_node)
9966         type = complex_integer_type_node;
9967       else if (type == float_type_node)
9968         type = complex_float_type_node;
9969       else if (type == double_type_node)
9970         type = complex_double_type_node;
9971       else if (type == long_double_type_node)
9972         type = complex_long_double_type_node;
9973       else
9974         type = build_complex_type (type);
9975     }
9976
9977   if (return_type == return_conversion
9978       && (RIDBIT_SETP (RID_CONST, specbits)
9979           || RIDBIT_SETP (RID_VOLATILE, specbits)
9980           || RIDBIT_SETP (RID_RESTRICT, specbits)))
9981     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9982               ctor_return_type);
9983
9984   /* Set CONSTP if this declaration is `const', whether by
9985      explicit specification or via a typedef.
9986      Likewise for VOLATILEP.  */
9987
9988   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
9989   restrictp =
9990     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
9991   volatilep =
9992     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
9993   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
9994                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
9995                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
9996   type = cp_build_qualified_type (type, type_quals);
9997   staticp = 0;
9998   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
9999   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10000   RIDBIT_RESET (RID_VIRTUAL, specbits);
10001   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10002   RIDBIT_RESET (RID_EXPLICIT, specbits);
10003
10004   if (RIDBIT_SETP (RID_STATIC, specbits))
10005     staticp = 1 + (decl_context == FIELD);
10006
10007   if (virtualp && staticp == 2)
10008     {
10009       cp_error ("member `%D' cannot be declared both virtual and static",
10010                 dname);
10011       staticp = 0;
10012     }
10013   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10014   RIDBIT_RESET (RID_FRIEND, specbits);
10015
10016   /* Warn if two storage classes are given. Default to `auto'.  */
10017
10018   if (RIDBIT_ANY_SET (specbits))
10019     {
10020       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10021       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10022       if (decl_context == PARM && nclasses > 0)
10023         error ("storage class specifiers invalid in parameter declarations");
10024       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10025         {
10026           if (decl_context == PARM)
10027             error ("typedef declaration invalid in parameter declaration");
10028           nclasses++;
10029         }
10030       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10031       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10032     }
10033
10034   /* Give error if `virtual' is used outside of class declaration.  */
10035   if (virtualp
10036       && (current_class_name == NULL_TREE || decl_context != FIELD))
10037     {
10038       error ("virtual outside class declaration");
10039       virtualp = 0;
10040     }
10041
10042   /* Static anonymous unions are dealt with here.  */
10043   if (staticp && decl_context == TYPENAME
10044       && TREE_CODE (declspecs) == TREE_LIST
10045       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10046     decl_context = FIELD;
10047
10048   /* Warn about storage classes that are invalid for certain
10049      kinds of declarations (parameters, typenames, etc.).  */
10050
10051   if (nclasses > 1)
10052     error ("multiple storage classes in declaration of `%s'", name);
10053   else if (decl_context != NORMAL && nclasses > 0)
10054     {
10055       if ((decl_context == PARM || decl_context == CATCHPARM)
10056           && (RIDBIT_SETP (RID_REGISTER, specbits)
10057               || RIDBIT_SETP (RID_AUTO, specbits)))
10058         ;
10059       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10060         ;
10061       else if (decl_context == FIELD
10062                /* C++ allows static class elements  */
10063                && RIDBIT_SETP (RID_STATIC, specbits))
10064         /* C++ also allows inlines and signed and unsigned elements,
10065            but in those cases we don't come in here.  */
10066         ;
10067       else
10068         {
10069           if (decl_context == FIELD)
10070             {
10071               tree tmp = NULL_TREE;
10072               register int op = 0;
10073
10074               if (declarator)
10075                 {
10076                   /* Avoid trying to get an operand off an identifier node.  */
10077                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10078                     tmp = declarator;
10079                   else
10080                     tmp = TREE_OPERAND (declarator, 0);
10081                   op = IDENTIFIER_OPNAME_P (tmp);
10082                 }
10083               error ("storage class specified for %s `%s'",
10084                      op ? "member operator" : "field",
10085                      op ? operator_name_string (tmp) : name);
10086             }
10087           else
10088             {
10089               if (decl_context == PARM || decl_context == CATCHPARM)
10090                 error ("storage class specified for parameter `%s'", name);
10091               else
10092                 error ("storage class specified for typename");
10093             }
10094           RIDBIT_RESET (RID_REGISTER, specbits);
10095           RIDBIT_RESET (RID_AUTO, specbits);
10096           RIDBIT_RESET (RID_EXTERN, specbits);
10097         }
10098     }
10099   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10100     {
10101       if (toplevel_bindings_p ())
10102         {
10103           /* It's common practice (and completely valid) to have a const
10104              be initialized and declared extern.  */
10105           if (!(type_quals & TYPE_QUAL_CONST))
10106             warning ("`%s' initialized and declared `extern'", name);
10107         }
10108       else
10109         error ("`%s' has both `extern' and initializer", name);
10110     }
10111   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10112            && ! toplevel_bindings_p ())
10113     error ("nested function `%s' declared `extern'", name);
10114   else if (toplevel_bindings_p ())
10115     {
10116       if (RIDBIT_SETP (RID_AUTO, specbits))
10117         error ("top-level declaration of `%s' specifies `auto'", name);
10118     }
10119
10120   if (nclasses > 0 && friendp)
10121     error ("storage class specifiers invalid in friend function declarations");
10122
10123   /* Now figure out the structure of the declarator proper.
10124      Descend through it, creating more complex types, until we reach
10125      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10126
10127   inner_attrs = NULL_TREE;
10128   ignore_attrs = 0;
10129
10130   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10131          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10132     {
10133       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10134          an INDIRECT_REF (for *...),
10135          a CALL_EXPR (for ...(...)),
10136          an identifier (for the name being declared)
10137          or a null pointer (for the place in an absolute declarator
10138          where the name was omitted).
10139          For the last two cases, we have just exited the loop.
10140
10141          For C++ it could also be
10142          a SCOPE_REF (for class :: ...).  In this case, we have converted
10143          sensible names to types, and those are the values we use to
10144          qualify the member name.
10145          an ADDR_EXPR (for &...),
10146          a BIT_NOT_EXPR (for destructors)
10147
10148          At this point, TYPE is the type of elements of an array,
10149          or for a function to return, or for a pointer to point to.
10150          After this sequence of ifs, TYPE is the type of the
10151          array or function or pointer, and DECLARATOR has had its
10152          outermost layer removed.  */
10153
10154       if (type == error_mark_node)
10155         {
10156           if (TREE_CODE (declarator) == SCOPE_REF)
10157             declarator = TREE_OPERAND (declarator, 1);
10158           else
10159             declarator = TREE_OPERAND (declarator, 0);
10160           continue;
10161         }
10162       if (quals != NULL_TREE
10163           && (declarator == NULL_TREE
10164               || TREE_CODE (declarator) != SCOPE_REF))
10165         {
10166           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10167             ctype = TYPE_METHOD_BASETYPE (type);
10168           if (ctype != NULL_TREE)
10169             {
10170               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10171               grok_method_quals (ctype, dummy, quals);
10172               type = TREE_TYPE (dummy);
10173               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10174               quals = NULL_TREE;
10175             }
10176         }
10177
10178       /* See the comment for the TREE_LIST case, below.  */
10179       if (ignore_attrs)
10180         ignore_attrs = 0;
10181       else if (inner_attrs)
10182         {
10183           decl_attributes (type, inner_attrs, NULL_TREE);
10184           inner_attrs = NULL_TREE;
10185         }
10186
10187       switch (TREE_CODE (declarator))
10188         {
10189         case TREE_LIST:
10190           {
10191             /* We encode a declarator with embedded attributes using
10192                a TREE_LIST.  The attributes apply to the declarator
10193                directly inside them, so we have to skip an iteration
10194                before applying them to the type.  If the declarator just
10195                inside is the declarator-id, we apply the attrs to the
10196                decl itself.  */
10197             inner_attrs = TREE_PURPOSE (declarator);
10198             ignore_attrs = 1;
10199             declarator = TREE_VALUE (declarator);
10200           }
10201           break;
10202
10203         case ARRAY_REF:
10204           {
10205             register tree size;
10206
10207             size = TREE_OPERAND (declarator, 1);
10208
10209             /* VC++ spells a zero-sized array with [].  */
10210             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10211                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10212               size = integer_zero_node;
10213
10214             declarator = TREE_OPERAND (declarator, 0);
10215
10216             type = create_array_type_for_decl (dname, type, size);
10217             ctype = NULL_TREE;
10218           }
10219           break;
10220
10221         case CALL_EXPR:
10222           {
10223             tree arg_types;
10224             int funcdecl_p;
10225             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10226             tree inner_decl = TREE_OPERAND (declarator, 0);
10227
10228             /* Declaring a function type.
10229                Make sure we have a valid type for the function to return.  */
10230
10231             /* We now know that the TYPE_QUALS don't apply to the
10232                decl, but to its return type.  */
10233             type_quals = TYPE_UNQUALIFIED;
10234
10235             /* Warn about some types functions can't return.  */
10236
10237             if (TREE_CODE (type) == FUNCTION_TYPE)
10238               {
10239                 error ("`%s' declared as function returning a function", name);
10240                 type = integer_type_node;
10241               }
10242             if (TREE_CODE (type) == ARRAY_TYPE)
10243               {
10244                 error ("`%s' declared as function returning an array", name);
10245                 type = integer_type_node;
10246               }
10247
10248             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10249               inner_decl = TREE_OPERAND (inner_decl, 1);
10250
10251             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10252               inner_decl = dname;
10253
10254             /* Pick up type qualifiers which should be applied to `this'.  */
10255             quals = CALL_DECLARATOR_QUALS (declarator);
10256
10257             /* Pick up the exception specifications.  */
10258             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10259
10260             /* Say it's a definition only for the CALL_EXPR
10261                closest to the identifier.  */
10262             funcdecl_p
10263               = inner_decl
10264               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10265                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10266                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10267
10268             if (ctype == NULL_TREE
10269                 && decl_context == FIELD
10270                 && funcdecl_p
10271                 && (friendp == 0 || dname == current_class_name))
10272               ctype = current_class_type;
10273
10274             if (ctype && return_type == return_conversion)
10275               TYPE_HAS_CONVERSION (ctype) = 1;
10276             if (ctype && constructor_name (ctype) == dname)
10277               {
10278                 /* We are within a class's scope. If our declarator name
10279                    is the same as the class name, and we are defining
10280                    a function, then it is a constructor/destructor, and
10281                    therefore returns a void type.  */
10282
10283                 if (flags == DTOR_FLAG)
10284                   {
10285                     /* ISO C++ 12.4/2.  A destructor may not be
10286                        declared const or volatile.  A destructor may
10287                        not be static.  */
10288                     if (staticp == 2)
10289                       error ("destructor cannot be static member function");
10290                     if (quals)
10291                       {
10292                         cp_error ("destructors may not be `%s'",
10293                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10294                         quals = NULL_TREE;
10295                       }
10296                     if (decl_context == FIELD)
10297                       {
10298                         if (! member_function_or_else (ctype,
10299                                                        current_class_type,
10300                                                        flags))
10301                           return void_type_node;
10302                       }
10303                   }
10304                 else            /* It's a constructor.  */
10305                   {
10306                     if (explicitp == 1)
10307                       explicitp = 2;
10308                     /* ISO C++ 12.1.  A constructor may not be
10309                        declared const or volatile.  A constructor may
10310                        not be virtual.  A constructor may not be
10311                        static.  */
10312                     if (staticp == 2)
10313                       error ("constructor cannot be static member function");
10314                     if (virtualp)
10315                       {
10316                         pedwarn ("constructors cannot be declared virtual");
10317                         virtualp = 0;
10318                       }
10319                     if (quals)
10320                       {
10321                         cp_error ("constructors may not be `%s'",
10322                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10323                         quals = NULL_TREE;
10324                       }
10325                     {
10326                       RID_BIT_TYPE tmp_bits;
10327                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10328                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10329                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10330                       if (RIDBIT_ANY_SET (tmp_bits))
10331                         error ("return value type specifier for constructor ignored");
10332                     }
10333                     type = build_pointer_type (ctype);
10334                     if (decl_context == FIELD)
10335                       {
10336                         if (! member_function_or_else (ctype,
10337                                                        current_class_type,
10338                                                        flags))
10339                           return void_type_node;
10340                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10341                         if (return_type != return_ctor)
10342                           return NULL_TREE;
10343                       }
10344                   }
10345                 if (decl_context == FIELD)
10346                   staticp = 0;
10347               }
10348             else if (friendp)
10349               {
10350                 if (initialized)
10351                   error ("can't initialize friend function `%s'", name);
10352                 if (virtualp)
10353                   {
10354                     /* Cannot be both friend and virtual.  */
10355                     error ("virtual functions cannot be friends");
10356                     RIDBIT_RESET (RID_FRIEND, specbits);
10357                     friendp = 0;
10358                   }
10359                 if (decl_context == NORMAL)
10360                   error ("friend declaration not in class definition");
10361                 if (current_function_decl && funcdef_flag)
10362                   cp_error ("can't define friend function `%s' in a local class definition",
10363                             name);
10364               }
10365
10366             /* Construct the function type and go to the next
10367                inner layer of declarator.  */
10368
10369             declarator = TREE_OPERAND (declarator, 0);
10370
10371             /* FIXME: This is where default args should be fully
10372                processed.  */
10373
10374             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10375
10376             if (declarator && flags == DTOR_FLAG)
10377               {
10378                 /* A destructor declared in the body of a class will
10379                    be represented as a BIT_NOT_EXPR.  But, we just
10380                    want the underlying IDENTIFIER.  */
10381                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10382                   declarator = TREE_OPERAND (declarator, 0);
10383
10384                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10385                   arg_types = void_list_node;
10386                 else if (arg_types == NULL_TREE
10387                          || arg_types != void_list_node)
10388                   {
10389                     cp_error ("destructors may not have parameters");
10390                     arg_types = void_list_node;
10391                     last_function_parms = NULL_TREE;
10392                   }
10393               }
10394
10395             /* ANSI says that `const int foo ();'
10396                does not make the function foo const.  */
10397             type = build_function_type (type, arg_types);
10398
10399             {
10400               tree t;
10401               for (t = arg_types; t; t = TREE_CHAIN (t))
10402                 if (TREE_PURPOSE (t)
10403                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10404                   {
10405                     add_defarg_fn (type);
10406                     break;
10407                   }
10408             }
10409           }
10410           break;
10411
10412         case ADDR_EXPR:
10413         case INDIRECT_REF:
10414           /* Filter out pointers-to-references and references-to-references.
10415              We can get these if a TYPE_DECL is used.  */
10416
10417           if (TREE_CODE (type) == REFERENCE_TYPE)
10418             {
10419               error ("cannot declare %s to references",
10420                      TREE_CODE (declarator) == ADDR_EXPR
10421                      ? "references" : "pointers");
10422               declarator = TREE_OPERAND (declarator, 0);
10423               continue;
10424             }
10425
10426           if (TREE_CODE (type) == OFFSET_TYPE
10427               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10428                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10429             {
10430               cp_error ("cannot declare pointer to `%#T' member",
10431                         TREE_TYPE (type));
10432               type = TREE_TYPE (type);
10433             }
10434
10435           /* Merge any constancy or volatility into the target type
10436              for the pointer.  */
10437
10438           /* We now know that the TYPE_QUALS don't apply to the decl,
10439              but to the target of the pointer.  */
10440           type_quals = TYPE_UNQUALIFIED;
10441
10442           if (TREE_CODE (declarator) == ADDR_EXPR)
10443             {
10444               if (TREE_CODE (type) == VOID_TYPE)
10445                 error ("invalid type: `void &'");
10446               else
10447                 type = build_reference_type (type);
10448             }
10449           else if (TREE_CODE (type) == METHOD_TYPE)
10450             type = build_ptrmemfunc_type (build_pointer_type (type));
10451           else
10452             type = build_pointer_type (type);
10453
10454           /* Process a list of type modifier keywords (such as
10455              const or volatile) that were given inside the `*' or `&'.  */
10456
10457           if (TREE_TYPE (declarator))
10458             {
10459               register tree typemodlist;
10460               int erred = 0;
10461
10462               constp = 0;
10463               volatilep = 0;
10464               restrictp = 0;
10465               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10466                    typemodlist = TREE_CHAIN (typemodlist))
10467                 {
10468                   tree qualifier = TREE_VALUE (typemodlist);
10469
10470                   if (qualifier == ridpointers[(int) RID_CONST])
10471                     constp++;
10472                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10473                     volatilep++;
10474                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10475                     restrictp++;
10476                   else if (!erred)
10477                     {
10478                       erred = 1;
10479                       error ("invalid type modifier within pointer declarator");
10480                     }
10481                 }
10482               if (constp > 1)
10483                 pedwarn ("duplicate `const'");
10484               if (volatilep > 1)
10485                 pedwarn ("duplicate `volatile'");
10486               if (restrictp > 1)
10487                 pedwarn ("duplicate `restrict'");
10488
10489               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10490                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10491                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10492               if (TREE_CODE (declarator) == ADDR_EXPR
10493                   && (constp || volatilep))
10494                 {
10495                   if (constp)
10496                     pedwarn ("discarding `const' applied to a reference");
10497                   if (volatilep)
10498                     pedwarn ("discarding `volatile' applied to a reference");
10499                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10500                 }
10501               type = cp_build_qualified_type (type, type_quals);
10502             }
10503           declarator = TREE_OPERAND (declarator, 0);
10504           ctype = NULL_TREE;
10505           break;
10506
10507         case SCOPE_REF:
10508           {
10509             /* We have converted type names to NULL_TREE if the
10510                name was bogus, or to a _TYPE node, if not.
10511
10512                The variable CTYPE holds the type we will ultimately
10513                resolve to.  The code here just needs to build
10514                up appropriate member types.  */
10515             tree sname = TREE_OPERAND (declarator, 1);
10516             tree t;
10517
10518             /* Destructors can have their visibilities changed as well.  */
10519             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10520               sname = TREE_OPERAND (sname, 0);
10521
10522             if (TREE_COMPLEXITY (declarator) == 0)
10523               /* This needs to be here, in case we are called
10524                  multiple times.  */ ;
10525             else if (TREE_COMPLEXITY (declarator) == -1)
10526               /* Namespace member. */
10527               pop_decl_namespace ();
10528             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10529               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10530             else if (! IS_AGGR_TYPE_CODE
10531                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10532               ;
10533             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10534               {
10535                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10536                    that refer to ctype.  They couldn't be resolved earlier
10537                    because we hadn't pushed into the class yet.
10538                    Example: resolve 'B<T>::type' in
10539                    'B<typename B<T>::type> B<T>::f () { }'.  */
10540                 if (current_template_parms
10541                     && uses_template_parms (type)
10542                     && uses_template_parms (current_class_type))
10543                   {
10544                     tree args = current_template_args ();
10545                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10546                   }
10547
10548                 /* This pop_nested_class corresponds to the
10549                    push_nested_class used to push into class scope for
10550                    parsing the argument list of a function decl, in
10551                    qualified_id.  */
10552                 pop_nested_class ();
10553                 TREE_COMPLEXITY (declarator) = current_class_depth;
10554               }
10555             else
10556               my_friendly_abort (16);
10557
10558             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10559               {
10560                 /* We had a reference to a global decl, or
10561                    perhaps we were given a non-aggregate typedef,
10562                    in which case we cleared this out, and should just
10563                    keep going as though it wasn't there.  */
10564                 declarator = sname;
10565                 continue;
10566               }
10567             ctype = TREE_OPERAND (declarator, 0);
10568
10569             t = ctype;
10570             while (t != NULL_TREE && CLASS_TYPE_P (t))
10571               {
10572                 if (CLASSTYPE_TEMPLATE_INFO (t) &&
10573                     !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
10574                   template_count += 1;
10575                 t = TYPE_MAIN_DECL (t);
10576                 if (DECL_LANG_SPECIFIC (t))
10577                   t = DECL_CONTEXT (t);
10578                 else
10579                   t = NULL_TREE;
10580               }
10581
10582             if (sname == NULL_TREE)
10583               goto done_scoping;
10584
10585             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10586               {
10587                 /* This is the `standard' use of the scoping operator:
10588                    basetype :: member .  */
10589
10590                 if (ctype == current_class_type)
10591                   {
10592                     /* class A {
10593                          void A::f ();
10594                        };
10595
10596                        Is this ill-formed?  */
10597
10598                     if (pedantic)
10599                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10600                                   ctype, name);
10601                   }
10602                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10603                   {
10604                     if (current_class_type == NULL_TREE
10605                         || friendp)
10606                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10607                                                       TYPE_ARG_TYPES (type));
10608                     else
10609                       {
10610                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10611                                   ctype, name, current_class_type);
10612                         return void_type_node;
10613                       }
10614                   }
10615                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10616                          || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
10617                   {
10618                     /* Have to move this code elsewhere in this function.
10619                        this code is used for i.e., typedef int A::M; M *pm;
10620
10621                        It is?  How? jason 10/2/94 */
10622
10623                     if (current_class_type)
10624                       {
10625                         cp_error ("cannot declare member `%T::%s' within `%T'",
10626                                   ctype, name, current_class_type);
10627                         return void_type_node;
10628                       }
10629                     type = build_offset_type (ctype, type);
10630                   }
10631                 else if (uses_template_parms (ctype))
10632                   {
10633                     if (TREE_CODE (type) == FUNCTION_TYPE)
10634                       type
10635                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10636                                                    TYPE_ARG_TYPES (type));
10637                   }
10638                 else
10639                   {
10640                     cp_error ("structure `%T' not yet defined", ctype);
10641                     return error_mark_node;
10642                   }
10643
10644                 declarator = sname;
10645               }
10646             else if (TREE_CODE (sname) == SCOPE_REF)
10647               my_friendly_abort (17);
10648             else
10649               {
10650               done_scoping:
10651                 declarator = TREE_OPERAND (declarator, 1);
10652                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10653                   /* In this case, we will deal with it later.  */
10654                   ;
10655                 else
10656                   {
10657                     if (TREE_CODE (type) == FUNCTION_TYPE)
10658                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10659                                                       TYPE_ARG_TYPES (type));
10660                     else
10661                       type = build_offset_type (ctype, type);
10662                   }
10663               }
10664           }
10665           break;
10666
10667         case BIT_NOT_EXPR:
10668           declarator = TREE_OPERAND (declarator, 0);
10669           break;
10670
10671         case RECORD_TYPE:
10672         case UNION_TYPE:
10673         case ENUMERAL_TYPE:
10674           declarator = NULL_TREE;
10675           break;
10676
10677         case ERROR_MARK:
10678           declarator = NULL_TREE;
10679           break;
10680
10681         default:
10682           my_friendly_abort (158);
10683         }
10684     }
10685
10686   /* See the comment for the TREE_LIST case, above.  */
10687   if (inner_attrs)
10688     {
10689       if (! ignore_attrs)
10690         decl_attributes (type, inner_attrs, NULL_TREE);
10691       else if (attrlist)
10692         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10693       else
10694         attrlist = build_decl_list (NULL_TREE, inner_attrs);
10695     }
10696
10697   /* Now TYPE has the actual type.  */
10698
10699   if (explicitp == 1 || (explicitp && friendp))
10700     {
10701       /* [dcl.fct.spec] The explicit specifier shall only be used in
10702          declarations of constructors within a class definition.  */
10703       error ("only declarations of constructors can be `explicit'");
10704       explicitp = 0;
10705     }
10706
10707   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10708     {
10709       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10710         {
10711           error ("non-member `%s' cannot be declared `mutable'", name);
10712           RIDBIT_RESET (RID_MUTABLE, specbits);
10713         }
10714       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10715         {
10716           error ("non-object member `%s' cannot be declared `mutable'", name);
10717           RIDBIT_RESET (RID_MUTABLE, specbits);
10718         }
10719       else if (TREE_CODE (type) == FUNCTION_TYPE
10720                || TREE_CODE (type) == METHOD_TYPE)
10721         {
10722           error ("function `%s' cannot be declared `mutable'", name);
10723           RIDBIT_RESET (RID_MUTABLE, specbits);
10724         }
10725       else if (staticp)
10726         {
10727           error ("static `%s' cannot be declared `mutable'", name);
10728           RIDBIT_RESET (RID_MUTABLE, specbits);
10729         }
10730       else if (type_quals & TYPE_QUAL_CONST)
10731         {
10732           error ("const `%s' cannot be declared `mutable'", name);
10733           RIDBIT_RESET (RID_MUTABLE, specbits);
10734         }
10735     }
10736
10737   if (declarator == NULL_TREE
10738       || TREE_CODE (declarator) == IDENTIFIER_NODE
10739       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10740           && (TREE_CODE (type) == FUNCTION_TYPE
10741               || TREE_CODE (type) == METHOD_TYPE)))
10742     /* OK */;
10743   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10744     {
10745       cp_error ("template-id `%D' used as a declarator", declarator);
10746       declarator = dname;
10747     }
10748   else
10749     /* Unexpected declarator format.  */
10750     my_friendly_abort (990210);
10751
10752   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10753
10754   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10755     {
10756       tree decl;
10757
10758       /* Note that the grammar rejects storage classes
10759          in typenames, fields or parameters.  */
10760       if (current_lang_name == lang_name_java)
10761         TYPE_FOR_JAVA (type) = 1;
10762
10763       if (decl_context == FIELD)
10764         {
10765           if (declarator == constructor_name (current_class_type))
10766             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10767                         declarator);
10768           decl = build_lang_decl (TYPE_DECL, declarator, type);
10769         }
10770       else
10771         {
10772           /* Make sure this typedef lives as long as its type,
10773              since it might be used as a template parameter. */
10774           if (processing_template_decl)
10775             decl = build_lang_decl (TYPE_DECL, declarator, type);
10776           else
10777             decl = build_decl (TYPE_DECL, declarator, type);
10778         }
10779
10780       /* If the user declares "typedef struct {...} foo" then the
10781          struct will have an anonymous name.  Fill that name in now.
10782          Nothing can refer to it, so nothing needs know about the name
10783          change.  */
10784       if (type != error_mark_node
10785           && TYPE_NAME (type)
10786           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10787           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10788           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10789         {
10790           tree oldname = TYPE_NAME (type);
10791           tree t;
10792
10793           /* Replace the anonymous name with the real name everywhere.  */
10794           lookup_tag_reverse (type, declarator);
10795           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10796             if (TYPE_NAME (t) == oldname)
10797               TYPE_NAME (t) = decl;
10798
10799           if (TYPE_LANG_SPECIFIC (type))
10800             TYPE_WAS_ANONYMOUS (type) = 1;
10801
10802           /* If this is a typedef within a template class, the nested
10803              type is a (non-primary) template.  The name for the
10804              template needs updating as well.  */
10805           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10806             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10807               = TYPE_IDENTIFIER (type);
10808
10809           /* XXX Temporarily set the scope.
10810              When returning, start_decl expects it as NULL_TREE,
10811              and will then then set it using pushdecl. */
10812           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10813           if (current_class_type)
10814             DECL_CONTEXT (decl) = current_class_type;
10815           else
10816             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10817
10818           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10819           DECL_ASSEMBLER_NAME (decl)
10820             = get_identifier (build_overload_name (type, 1, 1));
10821           DECL_CONTEXT (decl) = NULL_TREE;
10822
10823           /* FIXME remangle member functions; member functions of a
10824              type with external linkage have external linkage.  */
10825         }
10826
10827       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10828         {
10829           cp_error_at ("typedef name may not be class-qualified", decl);
10830           return NULL_TREE;
10831         }
10832       else if (quals)
10833         {
10834           if (ctype == NULL_TREE)
10835             {
10836               if (TREE_CODE (type) != METHOD_TYPE)
10837                 cp_error_at ("invalid type qualifier for non-member function type", decl);
10838               else
10839                 ctype = TYPE_METHOD_BASETYPE (type);
10840             }
10841           if (ctype != NULL_TREE)
10842             grok_method_quals (ctype, decl, quals);
10843         }
10844
10845       if (RIDBIT_SETP (RID_SIGNED, specbits)
10846           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10847         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10848
10849       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
10850                       inlinep, friendp, raises != NULL_TREE);
10851
10852       if (initialized)
10853         error ("typedef declaration includes an initializer");
10854
10855       return decl;
10856     }
10857
10858   /* Detect the case of an array type of unspecified size
10859      which came, as such, direct from a typedef name.
10860      We must copy the type, so that each identifier gets
10861      a distinct type, so that each identifier's size can be
10862      controlled separately by its own initializer.  */
10863
10864   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
10865       && TYPE_DOMAIN (type) == NULL_TREE)
10866     {
10867       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
10868     }
10869
10870   /* If this is a type name (such as, in a cast or sizeof),
10871      compute the type and return it now.  */
10872
10873   if (decl_context == TYPENAME)
10874     {
10875       /* Note that the grammar rejects storage classes
10876          in typenames, fields or parameters.  */
10877       if (type_quals != TYPE_UNQUALIFIED)
10878         type_quals = TYPE_UNQUALIFIED;
10879
10880       /* Special case: "friend class foo" looks like a TYPENAME context.  */
10881       if (friendp)
10882         {
10883           if (type_quals != TYPE_UNQUALIFIED)
10884             {
10885               cp_error ("type qualifiers specified for friend class declaration");
10886               type_quals = TYPE_UNQUALIFIED;
10887             }
10888           if (inlinep)
10889             {
10890               cp_error ("`inline' specified for friend class declaration");
10891               inlinep = 0;
10892             }
10893
10894           /* Only try to do this stuff if we didn't already give up.  */
10895           if (type != integer_type_node)
10896             {
10897               /* A friendly class?  */
10898               if (current_class_type)
10899                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
10900               else
10901                 error ("trying to make class `%s' a friend of global scope",
10902                        TYPE_NAME_STRING (type));
10903               type = void_type_node;
10904             }
10905         }
10906       else if (quals)
10907         {
10908           if (ctype == NULL_TREE)
10909             {
10910               if (TREE_CODE (type) != METHOD_TYPE)
10911                 cp_error ("invalid qualifiers on non-member function type");
10912               else
10913                 ctype = TYPE_METHOD_BASETYPE (type);
10914             }
10915           if (ctype)
10916             {
10917               tree dummy = build_decl (TYPE_DECL, declarator, type);
10918               grok_method_quals (ctype, dummy, quals);
10919               type = TREE_TYPE (dummy);
10920             }
10921         }
10922
10923       return type;
10924     }
10925   else if (declarator == NULL_TREE && decl_context != PARM
10926            && decl_context != CATCHPARM
10927            && TREE_CODE (type) != UNION_TYPE
10928            && ! bitfield)
10929     {
10930       cp_error ("abstract declarator `%T' used as declaration", type);
10931       declarator = make_anon_name ();
10932     }
10933
10934   /* `void' at top level (not within pointer)
10935      is allowed only in typedefs or type names.
10936      We don't complain about parms either, but that is because
10937      a better error message can be made later.  */
10938
10939   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
10940     {
10941       if (! declarator)
10942         error ("unnamed variable or field declared void");
10943       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10944         {
10945           if (IDENTIFIER_OPNAME_P (declarator))
10946             my_friendly_abort (356);
10947           else
10948             error ("variable or field `%s' declared void", name);
10949         }
10950       else
10951         error ("variable or field declared void");
10952       type = integer_type_node;
10953     }
10954
10955   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10956      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
10957
10958   if (decl_context == PARM || decl_context == CATCHPARM)
10959     {
10960       if (ctype || in_namespace)
10961         error ("cannot use `::' in parameter declaration");
10962
10963       /* A parameter declared as an array of T is really a pointer to T.
10964          One declared as a function is really a pointer to a function.
10965          One declared as a member is really a pointer to member.  */
10966
10967       if (TREE_CODE (type) == ARRAY_TYPE)
10968         {
10969           /* Transfer const-ness of array into that of type pointed to.  */
10970           type = build_pointer_type (TREE_TYPE (type));
10971           type_quals = TYPE_UNQUALIFIED;
10972         }
10973       else if (TREE_CODE (type) == FUNCTION_TYPE)
10974         type = build_pointer_type (type);
10975       else if (TREE_CODE (type) == OFFSET_TYPE)
10976         type = build_pointer_type (type);
10977       else if (TREE_CODE (type) == VOID_TYPE && declarator)
10978         {
10979           error ("declaration of `%s' as void", name);
10980           return NULL_TREE;
10981         }
10982     }
10983
10984   {
10985     register tree decl;
10986
10987     if (decl_context == PARM)
10988       {
10989         decl = build_decl (PARM_DECL, declarator, type);
10990
10991         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
10992                         inlinep, friendp, raises != NULL_TREE);
10993
10994         /* Compute the type actually passed in the parmlist,
10995            for the case where there is no prototype.
10996            (For example, shorts and chars are passed as ints.)
10997            When there is a prototype, this is overridden later.  */
10998
10999         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11000       }
11001     else if (decl_context == FIELD)
11002       {
11003         if (type == error_mark_node)
11004           {
11005             /* Happens when declaring arrays of sizes which
11006                are error_mark_node, for example.  */
11007             decl = NULL_TREE;
11008           }
11009         else if (in_namespace && !friendp)
11010           {
11011             /* Something like struct S { int N::j; };  */
11012             cp_error ("invalid use of `::'");
11013             decl = NULL_TREE;
11014           }
11015         else if (TREE_CODE (type) == FUNCTION_TYPE)
11016           {
11017             int publicp = 0;
11018             tree function_context;
11019
11020             /* We catch the others as conflicts with the builtin
11021                typedefs.  */
11022             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11023               {
11024                 cp_error ("function `%D' cannot be declared friend",
11025                           declarator);
11026                 friendp = 0;
11027               }
11028
11029             if (friendp == 0)
11030               {
11031                 if (ctype == NULL_TREE)
11032                   ctype = current_class_type;
11033
11034                 if (ctype == NULL_TREE)
11035                   {
11036                     cp_error ("can't make `%D' into a method -- not in a class",
11037                               declarator);
11038                     return void_type_node;
11039                   }
11040
11041                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11042                    ARM 9.5 */
11043                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11044                   {
11045                     cp_error ("function `%D' declared virtual inside a union",
11046                               declarator);
11047                     return void_type_node;
11048                   }
11049
11050                 if (declarator == ansi_opname[(int) NEW_EXPR]
11051                     || declarator == ansi_opname[(int) VEC_NEW_EXPR]
11052                     || declarator == ansi_opname[(int) DELETE_EXPR]
11053                     || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
11054                   {
11055                     if (virtualp)
11056                       {
11057                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11058                                   declarator);
11059                         virtualp = 0;
11060                       }
11061                   }
11062                 else if (staticp < 2)
11063                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11064                                                   TYPE_ARG_TYPES (type));
11065               }
11066
11067             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11068             function_context = (ctype != NULL_TREE) ?
11069               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11070             publicp = (! friendp || ! staticp)
11071               && function_context == NULL_TREE;
11072             decl = grokfndecl (ctype, type,
11073                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11074                                ? declarator : dname,
11075                                declarator,
11076                                virtualp, flags, quals, raises,
11077                                friendp ? -1 : 0, friendp, publicp, inlinep,
11078                                funcdef_flag, template_count, in_namespace);
11079             if (decl == NULL_TREE)
11080               return decl;
11081 #if 0
11082             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11083             /* The decl and setting of decl_machine_attr is also turned off.  */
11084             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11085 #endif
11086
11087             /* [class.conv.ctor]
11088
11089                A constructor declared without the function-specifier
11090                explicit that can be called with a single parameter
11091                specifies a conversion from the type of its first
11092                parameter to the type of its class.  Such a constructor
11093                is called a converting constructor.  */
11094             if (explicitp == 2)
11095               DECL_NONCONVERTING_P (decl) = 1;
11096             else if (DECL_CONSTRUCTOR_P (decl))
11097               {
11098                 /* The constructor can be called with exactly one
11099                    parameter if there is at least one parameter, and
11100                    any subsequent parameters have default arguments.
11101                    We don't look at the first parameter, which is
11102                    really just the `this' parameter for the new
11103                    object.  */
11104                 tree arg_types =
11105                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11106
11107                 /* Skip the `in_chrg' argument too, if present.  */
11108                 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl)))
11109                   arg_types = TREE_CHAIN (arg_types);
11110
11111                 if (arg_types == void_list_node
11112                     || (arg_types
11113                         && TREE_CHAIN (arg_types)
11114                         && TREE_CHAIN (arg_types) != void_list_node
11115                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11116                   DECL_NONCONVERTING_P (decl) = 1;
11117               }
11118           }
11119         else if (TREE_CODE (type) == METHOD_TYPE)
11120           {
11121             /* We only get here for friend declarations of
11122                members of other classes.  */
11123             /* All method decls are public, so tell grokfndecl to set
11124                TREE_PUBLIC, also.  */
11125             decl = grokfndecl (ctype, type, declarator, declarator,
11126                                virtualp, flags, quals, raises,
11127                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11128                                template_count, in_namespace);
11129             if (decl == NULL_TREE)
11130               return NULL_TREE;
11131           }
11132         else if (!staticp && ! processing_template_decl
11133                  && TYPE_SIZE (complete_type (type)) == NULL_TREE
11134                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11135           {
11136             if (declarator)
11137               cp_error ("field `%D' has incomplete type", declarator);
11138             else
11139               cp_error ("name `%T' has incomplete type", type);
11140
11141             /* If we're instantiating a template, tell them which
11142                instantiation made the field's type be incomplete.  */
11143             if (current_class_type
11144                 && TYPE_NAME (current_class_type)
11145                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11146                 && declspecs && TREE_VALUE (declspecs)
11147                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11148               cp_error ("  in instantiation of template `%T'",
11149                         current_class_type);
11150
11151             type = error_mark_node;
11152             decl = NULL_TREE;
11153           }
11154         else
11155           {
11156             if (friendp)
11157               {
11158                 error ("`%s' is neither function nor member function; cannot be declared friend",
11159                        IDENTIFIER_POINTER (declarator));
11160                 friendp = 0;
11161               }
11162             decl = NULL_TREE;
11163           }
11164
11165         if (friendp)
11166           {
11167             /* Friends are treated specially.  */
11168             if (ctype == current_class_type)
11169               warning ("member functions are implicitly friends of their class");
11170             else
11171               {
11172                 tree t = NULL_TREE;
11173                 if (decl && DECL_NAME (decl))
11174                   {
11175                     if (template_class_depth (current_class_type) == 0)
11176                       {
11177                         decl
11178                           = check_explicit_specialization
11179                           (declarator, decl,
11180                            template_count, 2 * (funcdef_flag != 0) + 4);
11181                         if (decl == error_mark_node)
11182                           return error_mark_node;
11183                       }
11184
11185                     t = do_friend (ctype, declarator, decl,
11186                                    last_function_parms, attrlist, flags, quals,
11187                                    funcdef_flag);
11188                   }
11189                 if (t && funcdef_flag)
11190                   return t;
11191
11192                 return void_type_node;
11193               }
11194           }
11195
11196         /* Structure field.  It may not be a function, except for C++ */
11197
11198         if (decl == NULL_TREE)
11199           {
11200             if (initialized)
11201               {
11202                 if (!staticp)
11203                   {
11204                     /* An attempt is being made to initialize a non-static
11205                        member.  But, from [class.mem]:
11206
11207                        4 A member-declarator can contain a
11208                        constant-initializer only if it declares a static
11209                        member (_class.static_) of integral or enumeration
11210                        type, see _class.static.data_.
11211
11212                        This used to be relatively common practice, but
11213                        the rest of the compiler does not correctly
11214                        handle the initialization unless the member is
11215                        static so we make it static below.  */
11216                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11217                                 declarator);
11218                     cp_pedwarn ("making `%D' static", declarator);
11219                     staticp = 1;
11220                   }
11221
11222                 if (uses_template_parms (type))
11223                   /* We'll check at instantiation time.  */
11224                   ;
11225                 else if (check_static_variable_definition (declarator,
11226                                                            type))
11227                   /* If we just return the declaration, crashes
11228                      will sometimes occur.  We therefore return
11229                      void_type_node, as if this was a friend
11230                      declaration, to cause callers to completely
11231                      ignore this declaration.  */
11232                   return void_type_node;
11233               }
11234
11235             /* 9.2p13 [class.mem] */
11236             if (declarator == constructor_name (current_class_type)
11237                 /* Divergence from the standard:  In extern "C", we
11238                    allow non-static data members here, because C does
11239                    and /usr/include/netinet/in.h uses that.  */
11240                 && (staticp || ! in_system_header))
11241               cp_pedwarn ("ISO C++ forbids data member `%D' with same name as enclosing class",
11242                           declarator);
11243
11244             if (staticp)
11245               {
11246                 /* C++ allows static class members.  All other work
11247                    for this is done by grokfield.  */
11248                 decl = build_lang_decl (VAR_DECL, declarator, type);
11249                 TREE_STATIC (decl) = 1;
11250                 /* In class context, 'static' means public access.  */
11251                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11252               }
11253             else
11254               {
11255                 decl = build_lang_decl (FIELD_DECL, declarator, type);
11256                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11257                   {
11258                     DECL_MUTABLE_P (decl) = 1;
11259                     RIDBIT_RESET (RID_MUTABLE, specbits);
11260                   }
11261               }
11262
11263             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11264                             inlinep, friendp, raises != NULL_TREE);
11265           }
11266       }
11267     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11268       {
11269         tree original_name;
11270         int publicp = 0;
11271
11272         if (! declarator)
11273           return NULL_TREE;
11274
11275         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11276           original_name = dname;
11277         else
11278           original_name = declarator;
11279
11280         if (RIDBIT_SETP (RID_AUTO, specbits))
11281           error ("storage class `auto' invalid for function `%s'", name);
11282         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11283           error ("storage class `register' invalid for function `%s'", name);
11284
11285         /* Function declaration not at top level.
11286            Storage classes other than `extern' are not allowed
11287            and `extern' makes no difference.  */
11288         if (! toplevel_bindings_p ()
11289             && (RIDBIT_SETP (RID_STATIC, specbits)
11290                 || RIDBIT_SETP (RID_INLINE, specbits))
11291             && pedantic)
11292           {
11293             if (RIDBIT_SETP (RID_STATIC, specbits))
11294               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11295             else
11296               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11297           }
11298
11299         if (ctype == NULL_TREE)
11300           {
11301             if (virtualp)
11302               {
11303                 error ("virtual non-class function `%s'", name);
11304                 virtualp = 0;
11305               }
11306           }
11307         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11308           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11309                                           TYPE_ARG_TYPES (type));
11310
11311         /* Record presence of `static'.  */
11312         publicp = (ctype != NULL_TREE
11313                    || RIDBIT_SETP (RID_EXTERN, specbits)
11314                    || !RIDBIT_SETP (RID_STATIC, specbits));
11315
11316         decl = grokfndecl (ctype, type, original_name, declarator,
11317                            virtualp, flags, quals, raises,
11318                            1, friendp,
11319                            publicp, inlinep, funcdef_flag,
11320                            template_count, in_namespace);
11321         if (decl == NULL_TREE)
11322           return NULL_TREE;
11323
11324         if (staticp == 1)
11325           {
11326             int illegal_static = 0;
11327
11328             /* Don't allow a static member function in a class, and forbid
11329                declaring main to be static.  */
11330             if (TREE_CODE (type) == METHOD_TYPE)
11331               {
11332                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11333                 illegal_static = 1;
11334               }
11335             else if (current_function_decl)
11336               {
11337                 /* FIXME need arm citation */
11338                 error ("cannot declare static function inside another function");
11339                 illegal_static = 1;
11340               }
11341
11342             if (illegal_static)
11343               {
11344                 staticp = 0;
11345                 RIDBIT_RESET (RID_STATIC, specbits);
11346               }
11347           }
11348       }
11349     else
11350       {
11351         /* It's a variable.  */
11352
11353         /* An uninitialized decl with `extern' is a reference.  */
11354         decl = grokvardecl (type, declarator, &specbits,
11355                             initialized,
11356                             (type_quals & TYPE_QUAL_CONST) != 0,
11357                             in_namespace);
11358         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11359                         inlinep, friendp, raises != NULL_TREE);
11360
11361         if (ctype)
11362           {
11363             DECL_CONTEXT (decl) = ctype;
11364             if (staticp == 1)
11365               {
11366                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11367                 staticp = 0;
11368                 RIDBIT_RESET (RID_STATIC, specbits);
11369               }
11370             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11371               {
11372                 cp_error ("static member `%D' declared `register'", decl);
11373                 RIDBIT_RESET (RID_REGISTER, specbits);
11374               }
11375             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11376               {
11377                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11378                             decl);
11379                 RIDBIT_RESET (RID_EXTERN, specbits);
11380               }
11381           }
11382       }
11383
11384     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11385
11386     /* Record `register' declaration for warnings on &
11387        and in case doing stupid register allocation.  */
11388
11389     if (RIDBIT_SETP (RID_REGISTER, specbits))
11390       DECL_REGISTER (decl) = 1;
11391
11392     if (RIDBIT_SETP (RID_EXTERN, specbits))
11393       DECL_THIS_EXTERN (decl) = 1;
11394
11395     if (RIDBIT_SETP (RID_STATIC, specbits))
11396       DECL_THIS_STATIC (decl) = 1;
11397
11398     /* Record constancy and volatility.  There's no need to do this
11399        when processing a template; we'll do this for the instantiated
11400        declaration based on the type of DECL.  */
11401     if (!processing_template_decl)
11402       c_apply_type_quals_to_decl (type_quals, decl);
11403
11404     return decl;
11405   }
11406 }
11407 \f
11408 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11409    An empty exprlist is a parmlist.  An exprlist which
11410    contains only identifiers at the global level
11411    is a parmlist.  Otherwise, it is an exprlist.  */
11412
11413 int
11414 parmlist_is_exprlist (exprs)
11415      tree exprs;
11416 {
11417   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11418     return 0;
11419
11420   if (toplevel_bindings_p ())
11421     {
11422       /* At the global level, if these are all identifiers,
11423          then it is a parmlist.  */
11424       while (exprs)
11425         {
11426           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11427             return 1;
11428           exprs = TREE_CHAIN (exprs);
11429         }
11430       return 0;
11431     }
11432   return 1;
11433 }
11434
11435 /* Subroutine of start_function.  Ensure that each of the parameter
11436    types (as listed in PARMS) is complete, as is required for a
11437    function definition.  */
11438
11439 static void
11440 require_complete_types_for_parms (parms)
11441      tree parms;
11442 {
11443   for (; parms; parms = TREE_CHAIN (parms))
11444     {
11445       tree type = TREE_TYPE (parms);
11446
11447       /* Try to complete the TYPE.  */
11448       type = complete_type (type);
11449
11450       if (type == error_mark_node)
11451         continue;
11452
11453       if (TYPE_SIZE (type) == NULL_TREE)
11454         {
11455           if (DECL_NAME (parms))
11456             error ("parameter `%s' has incomplete type",
11457                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11458           else
11459             error ("parameter has incomplete type");
11460           TREE_TYPE (parms) = error_mark_node;
11461         }
11462       else
11463         layout_decl (parms, 0);
11464     }
11465 }
11466
11467 /* Returns non-zero if T is a local variable.  */
11468
11469 int
11470 local_variable_p (t)
11471      tree t;
11472 {
11473   if ((TREE_CODE (t) == VAR_DECL
11474        /* A VAR_DECL with a context that is a _TYPE is a static data
11475           member.  */
11476        && !TYPE_P (CP_DECL_CONTEXT (t))
11477        /* Any other non-local variable must be at namespace scope.  */
11478        && !DECL_NAMESPACE_SCOPE_P (t))
11479       || (TREE_CODE (t) == PARM_DECL))
11480     return 1;
11481
11482   return 0;
11483 }
11484
11485 /* Returns non-zero if T is an automatic local variable or a label.
11486    (These are the declarations that need to be remapped when the code
11487    containing them is duplicated.)  */
11488
11489 int
11490 nonstatic_local_decl_p (t)
11491      tree t;
11492 {
11493   return ((local_variable_p (t) && !TREE_STATIC (t))
11494           || TREE_CODE (t) == LABEL_DECL
11495           || TREE_CODE (t) == RESULT_DECL);
11496 }
11497
11498 /* Like local_variable_p, but suitable for use as a tree-walking
11499    function.  */
11500
11501 static tree
11502 local_variable_p_walkfn (tp, walk_subtrees, data)
11503      tree *tp;
11504      int *walk_subtrees ATTRIBUTE_UNUSED;
11505      void *data ATTRIBUTE_UNUSED;
11506 {
11507   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11508           ? *tp : NULL_TREE);
11509 }
11510
11511 /* Check that ARG, which is a default-argument expression for a
11512    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11513    something goes wrong.  DECL may also be a _TYPE node, rather than a
11514    DECL, if there is no DECL available.  */
11515
11516 tree
11517 check_default_argument (decl, arg)
11518      tree decl;
11519      tree arg;
11520 {
11521   tree var;
11522   tree decl_type;
11523
11524   if (TREE_CODE (arg) == DEFAULT_ARG)
11525     /* We get a DEFAULT_ARG when looking at an in-class declaration
11526        with a default argument.  Ignore the argument for now; we'll
11527        deal with it after the class is complete.  */
11528     return arg;
11529
11530   if (processing_template_decl || uses_template_parms (arg))
11531     /* We don't do anything checking until instantiation-time.  Note
11532        that there may be uninstantiated arguments even for an
11533        instantiated function, since default arguments are not
11534        instantiated until they are needed.  */
11535     return arg;
11536
11537   if (TYPE_P (decl))
11538     {
11539       decl_type = decl;
11540       decl = NULL_TREE;
11541     }
11542   else
11543     decl_type = TREE_TYPE (decl);
11544
11545   if (arg == error_mark_node
11546       || decl == error_mark_node
11547       || TREE_TYPE (arg) == error_mark_node
11548       || decl_type == error_mark_node)
11549     /* Something already went wrong.  There's no need to check
11550        further.  */
11551     return error_mark_node;
11552
11553   /* [dcl.fct.default]
11554
11555      A default argument expression is implicitly converted to the
11556      parameter type.  */
11557   if (!TREE_TYPE (arg)
11558       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11559     {
11560       if (decl)
11561         cp_error ("default argument for `%#D' has type `%T'",
11562                   decl, TREE_TYPE (arg));
11563       else
11564         cp_error ("default argument for parameter of type `%T' has type `%T'",
11565                   decl_type, TREE_TYPE (arg));
11566
11567       return error_mark_node;
11568     }
11569
11570   /* [dcl.fct.default]
11571
11572      Local variables shall not be used in default argument
11573      expressions.
11574
11575      The keyword `this' shall not be used in a default argument of a
11576      member function.  */
11577   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11578   if (var)
11579     {
11580       cp_error ("default argument `%E' uses local variable `%D'",
11581                 arg, var);
11582       return error_mark_node;
11583     }
11584
11585   /* All is well.  */
11586   return arg;
11587 }
11588
11589 /* Decode the list of parameter types for a function type.
11590    Given the list of things declared inside the parens,
11591    return a list of types.
11592
11593    The list we receive can have three kinds of elements:
11594    an IDENTIFIER_NODE for names given without types,
11595    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11596    or void_type_node, to mark the end of an argument list
11597    when additional arguments are not permitted (... was not used).
11598
11599    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11600    a mere declaration.  A nonempty identifier-list gets an error message
11601    when FUNCDEF_FLAG is zero.
11602    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11603    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11604
11605    If all elements of the input list contain types,
11606    we return a list of the types.
11607    If all elements contain no type (except perhaps a void_type_node
11608    at the end), we return a null list.
11609    If some have types and some do not, it is an error, and we
11610    return a null list.
11611
11612    Also set last_function_parms to either
11613    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11614    A list of names is converted to a chain of PARM_DECLs
11615    by store_parm_decls so that ultimately it is always a chain of decls.
11616
11617    Note that in C++, parameters can take default values.  These default
11618    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11619    an error to specify default values which are followed by parameters
11620    that have no default values, or an ELLIPSES.  For simplicities sake,
11621    only parameters which are specified with their types can take on
11622    default values.  */
11623
11624 static tree
11625 grokparms (first_parm, funcdef_flag)
11626      tree first_parm;
11627      int funcdef_flag;
11628 {
11629   tree result = NULL_TREE;
11630   tree decls = NULL_TREE;
11631
11632   if (first_parm != NULL_TREE
11633       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11634     {
11635       if (! funcdef_flag)
11636         pedwarn ("parameter names (without types) in function declaration");
11637       last_function_parms = first_parm;
11638       return NULL_TREE;
11639     }
11640   else if (first_parm != NULL_TREE
11641            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11642            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11643     my_friendly_abort (145);
11644   else
11645     {
11646       /* Types were specified.  This is a list of declarators
11647          each represented as a TREE_LIST node.  */
11648       register tree parm, chain;
11649       int any_init = 0, any_error = 0;
11650
11651       if (first_parm != NULL_TREE)
11652         {
11653           tree last_result = NULL_TREE;
11654           tree last_decl = NULL_TREE;
11655
11656           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11657             {
11658               tree type = NULL_TREE, list_node = parm;
11659               register tree decl = TREE_VALUE (parm);
11660               tree init = TREE_PURPOSE (parm);
11661
11662               chain = TREE_CHAIN (parm);
11663               /* @@ weak defense against parse errors.  */
11664               if (TREE_CODE (decl) != VOID_TYPE
11665                   && TREE_CODE (decl) != TREE_LIST)
11666                 {
11667                   /* Give various messages as the need arises.  */
11668                   if (TREE_CODE (decl) == STRING_CST)
11669                     cp_error ("invalid string constant `%E'", decl);
11670                   else if (TREE_CODE (decl) == INTEGER_CST)
11671                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11672                   continue;
11673                 }
11674
11675               if (TREE_CODE (decl) != VOID_TYPE)
11676                 {
11677                   decl = grokdeclarator (TREE_VALUE (decl),
11678                                          TREE_PURPOSE (decl),
11679                                          PARM, init != NULL_TREE,
11680                                          NULL_TREE);
11681                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11682                     continue;
11683
11684                   /* Top-level qualifiers on the parameters are
11685                      ignored for function types.  */
11686                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11687
11688                   if (TREE_CODE (type) == VOID_TYPE)
11689                     decl = void_type_node;
11690                   else if (TREE_CODE (type) == METHOD_TYPE)
11691                     {
11692                       if (DECL_NAME (decl))
11693                         /* Cannot use the decl here because
11694                            we don't have DECL_CONTEXT set up yet.  */
11695                         cp_error ("parameter `%D' invalidly declared method type",
11696                                   DECL_NAME (decl));
11697                       else
11698                         error ("parameter invalidly declared method type");
11699                       type = build_pointer_type (type);
11700                       TREE_TYPE (decl) = type;
11701                     }
11702                   else if (TREE_CODE (type) == OFFSET_TYPE)
11703                     {
11704                       if (DECL_NAME (decl))
11705                         cp_error ("parameter `%D' invalidly declared offset type",
11706                                   DECL_NAME (decl));
11707                       else
11708                         error ("parameter invalidly declared offset type");
11709                       type = build_pointer_type (type);
11710                       TREE_TYPE (decl) = type;
11711                     }
11712                   else if (abstract_virtuals_error (decl, type))
11713                     any_error = 1;  /* Seems like a good idea. */
11714                   else if (POINTER_TYPE_P (type))
11715                     {
11716                       tree t = type;
11717                       while (POINTER_TYPE_P (t)
11718                              || (TREE_CODE (t) == ARRAY_TYPE
11719                                  && TYPE_DOMAIN (t) != NULL_TREE))
11720                         t = TREE_TYPE (t);
11721                       if (TREE_CODE (t) == ARRAY_TYPE)
11722                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
11723                                   type,
11724                                   TYPE_PTR_P (type) ? "pointer" : "reference");
11725                     }
11726                 }
11727
11728               if (TREE_CODE (decl) == VOID_TYPE)
11729                 {
11730                   if (result == NULL_TREE)
11731                     {
11732                       result = void_list_node;
11733                       last_result = result;
11734                     }
11735                   else
11736                     {
11737                       TREE_CHAIN (last_result) = void_list_node;
11738                       last_result = void_list_node;
11739                     }
11740                   if (chain
11741                       && (chain != void_list_node || TREE_CHAIN (chain)))
11742                     error ("`void' in parameter list must be entire list");
11743                   break;
11744                 }
11745
11746               /* Since there is a prototype, args are passed in their own types.  */
11747               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11748               if (PROMOTE_PROTOTYPES
11749                   && (TREE_CODE (type) == INTEGER_TYPE
11750                       || TREE_CODE (type) == ENUMERAL_TYPE)
11751                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11752                 DECL_ARG_TYPE (decl) = integer_type_node;
11753               if (!any_error && init)
11754                 {
11755                   any_init++;
11756                   init = check_default_argument (decl, init);
11757                 }
11758               else
11759                 init = NULL_TREE;
11760
11761               if (decls == NULL_TREE)
11762                 {
11763                   decls = decl;
11764                   last_decl = decls;
11765                 }
11766               else
11767                 {
11768                   TREE_CHAIN (last_decl) = decl;
11769                   last_decl = decl;
11770                 }
11771               list_node = tree_cons (init, type, NULL_TREE);
11772               if (result == NULL_TREE)
11773                 {
11774                   result = list_node;
11775                   last_result = result;
11776                 }
11777               else
11778                 {
11779                   TREE_CHAIN (last_result) = list_node;
11780                   last_result = list_node;
11781                 }
11782             }
11783           if (last_result)
11784             TREE_CHAIN (last_result) = NULL_TREE;
11785           /* If there are no parameters, and the function does not end
11786              with `...', then last_decl will be NULL_TREE.  */
11787           if (last_decl != NULL_TREE)
11788             TREE_CHAIN (last_decl) = NULL_TREE;
11789         }
11790     }
11791
11792   last_function_parms = decls;
11793
11794   return result;
11795 }
11796
11797 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11798    FUNCTION_TYPE with the newly parsed version of its default argument, which
11799    was previously digested as text.  See snarf_defarg et al in lex.c.  */
11800
11801 void
11802 replace_defarg (arg, init)
11803      tree arg, init;
11804 {
11805   if (! processing_template_decl
11806       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11807     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11808                 TREE_TYPE (init), TREE_VALUE (arg));
11809   TREE_PURPOSE (arg) = init;
11810 }
11811 \f
11812 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11813    D's arguments allow it to be a copy constructor, or copy assignment
11814    operator.  */
11815
11816 int
11817 copy_args_p (d)
11818      tree d;
11819 {
11820   tree t;
11821
11822   if (!DECL_FUNCTION_MEMBER_P (d))
11823     return 0;
11824
11825   t = FUNCTION_ARG_CHAIN (d);
11826   if (DECL_CONSTRUCTOR_P (d)
11827       && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
11828     t = TREE_CHAIN (t);
11829   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11830       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11831           == DECL_CONTEXT (d))
11832       && (TREE_CHAIN (t) == NULL_TREE
11833           || TREE_CHAIN (t) == void_list_node
11834           || TREE_PURPOSE (TREE_CHAIN (t))))
11835     return 1;
11836   return 0;
11837 }
11838
11839 /* These memoizing functions keep track of special properties which
11840    a class may have.  `grok_ctor_properties' notices whether a class
11841    has a constructor of the form X(X&), and also complains
11842    if the class has a constructor of the form X(X).
11843    `grok_op_properties' takes notice of the various forms of
11844    operator= which are defined, as well as what sorts of type conversion
11845    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11846
11847 int
11848 grok_ctor_properties (ctype, decl)
11849      tree ctype, decl;
11850 {
11851   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11852   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11853
11854   /* When a type has virtual baseclasses, a magical first int argument is
11855      added to any ctor so we can tell if the class has been initialized
11856      yet.  This could screw things up in this function, so we deliberately
11857      ignore the leading int if we're in that situation.  */
11858   if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
11859     {
11860       my_friendly_assert (parmtypes
11861                           && TREE_VALUE (parmtypes) == integer_type_node,
11862                           980529);
11863       parmtypes = TREE_CHAIN (parmtypes);
11864       parmtype = TREE_VALUE (parmtypes);
11865     }
11866
11867   /* [class.copy]
11868
11869      A non-template constructor for class X is a copy constructor if
11870      its first parameter is of type X&, const X&, volatile X& or const
11871      volatile X&, and either there are no other parameters or else all
11872      other parameters have default arguments.  */
11873   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11874       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11875       && (TREE_CHAIN (parmtypes) == NULL_TREE
11876           || TREE_CHAIN (parmtypes) == void_list_node
11877           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11878       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11879            && is_member_template (DECL_TI_TEMPLATE (decl))))
11880     {
11881       TYPE_HAS_INIT_REF (ctype) = 1;
11882       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11883         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11884     }
11885   /* [class.copy]
11886
11887      A declaration of a constructor for a class X is ill-formed if its
11888      first parameter is of type (optionally cv-qualified) X and either
11889      there are no other parameters or else all other parameters have
11890      default arguments.
11891
11892      We *don't* complain about member template instantiations that
11893      have this form, though; they can occur as we try to decide what
11894      constructor to use during overload resolution.  Since overload
11895      resolution will never prefer such a constructor to the
11896      non-template copy constructor (which is either explicitly or
11897      implicitly defined), there's no need to worry about their
11898      existence.  Theoretically, they should never even be
11899      instantiated, but that's hard to forestall.  */
11900   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11901            && (TREE_CHAIN (parmtypes) == NULL_TREE
11902                || TREE_CHAIN (parmtypes) == void_list_node
11903                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11904            && !(DECL_TEMPLATE_INSTANTIATION (decl)
11905                 && is_member_template (DECL_TI_TEMPLATE (decl))))
11906     {
11907       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11908                 ctype, ctype);
11909       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
11910       return 0;
11911     }
11912   else if (TREE_CODE (parmtype) == VOID_TYPE
11913            || TREE_PURPOSE (parmtypes) != NULL_TREE)
11914     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
11915
11916   return 1;
11917 }
11918
11919 /* An operator with this name can be either unary or binary.  */
11920
11921 static int
11922 ambi_op_p (name)
11923      tree name;
11924 {
11925   return (name == ansi_opname [(int) INDIRECT_REF]
11926           || name == ansi_opname [(int) ADDR_EXPR]
11927           || name == ansi_opname [(int) NEGATE_EXPR]
11928           || name == ansi_opname[(int) POSTINCREMENT_EXPR]
11929           || name == ansi_opname[(int) POSTDECREMENT_EXPR]
11930           || name == ansi_opname [(int) CONVERT_EXPR]);
11931 }
11932
11933 /* An operator with this name can only be unary.  */
11934
11935 static int
11936 unary_op_p (name)
11937      tree name;
11938 {
11939   return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
11940           || name == ansi_opname [(int) BIT_NOT_EXPR]
11941           || name == ansi_opname [(int) COMPONENT_REF]
11942           || IDENTIFIER_TYPENAME_P (name));
11943 }
11944
11945 /* Do a little sanity-checking on how they declared their operator.  */
11946
11947 void
11948 grok_op_properties (decl, virtualp, friendp)
11949      tree decl;
11950      int virtualp, friendp;
11951 {
11952   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11953   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11954   tree name = DECL_NAME (decl);
11955
11956   if (current_class_type == NULL_TREE)
11957     friendp = 1;
11958
11959   if (! friendp)
11960     {
11961       /* [class.copy]
11962
11963          A user-declared copy assignment operator X::operator= is a
11964          non-static non-template member function of class X with
11965          exactly one parameter of type X, X&, const X&, volatile X& or
11966          const volatile X&.  */
11967       if (name == ansi_opname[(int) MODIFY_EXPR]
11968           && !(DECL_TEMPLATE_INSTANTIATION (decl)
11969                && is_member_template (DECL_TI_TEMPLATE (decl))))
11970         ;
11971       else if (name == ansi_opname[(int) CALL_EXPR])
11972         TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
11973       else if (name == ansi_opname[(int) ARRAY_REF])
11974         TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
11975       else if (name == ansi_opname[(int) COMPONENT_REF]
11976                || name == ansi_opname[(int) MEMBER_REF])
11977         TYPE_OVERLOADS_ARROW (current_class_type) = 1;
11978       else if (name == ansi_opname[(int) NEW_EXPR])
11979         TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
11980       else if (name == ansi_opname[(int) DELETE_EXPR])
11981         TYPE_GETS_DELETE (current_class_type) |= 1;
11982       else if (name == ansi_opname[(int) VEC_NEW_EXPR])
11983         TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
11984       else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
11985         TYPE_GETS_DELETE (current_class_type) |= 2;
11986     }
11987
11988   if (name == ansi_opname[(int) NEW_EXPR]
11989       || name == ansi_opname[(int) VEC_NEW_EXPR])
11990     {
11991       /* When the compiler encounters the definition of A::operator new, it
11992          doesn't look at the class declaration to find out if it's static.  */
11993       if (methodp)
11994         revert_static_member_fn (&decl, NULL, NULL);
11995
11996       /* Take care of function decl if we had syntax errors.  */
11997       if (argtypes == NULL_TREE)
11998         TREE_TYPE (decl)
11999           = build_function_type (ptr_type_node,
12000                                  hash_tree_chain (integer_type_node,
12001                                                   void_list_node));
12002       else
12003         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12004     }
12005   else if (name == ansi_opname[(int) DELETE_EXPR]
12006            || name == ansi_opname[(int) VEC_DELETE_EXPR])
12007     {
12008       if (methodp)
12009         revert_static_member_fn (&decl, NULL, NULL);
12010
12011       if (argtypes == NULL_TREE)
12012         TREE_TYPE (decl)
12013           = build_function_type (void_type_node,
12014                                  hash_tree_chain (ptr_type_node,
12015                                                   void_list_node));
12016       else
12017         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12018     }
12019   else
12020     {
12021       /* An operator function must either be a non-static member function
12022          or have at least one parameter of a class, a reference to a class,
12023          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12024       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12025         {
12026           if (IDENTIFIER_TYPENAME_P (name)
12027               || name == ansi_opname[(int) CALL_EXPR]
12028               || name == ansi_opname[(int) MODIFY_EXPR]
12029               || name == ansi_opname[(int) COMPONENT_REF]
12030               || name == ansi_opname[(int) ARRAY_REF])
12031             cp_error ("`%D' must be a nonstatic member function", decl);
12032           else
12033             {
12034               tree p = argtypes;
12035
12036               if (DECL_STATIC_FUNCTION_P (decl))
12037                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12038
12039               if (p)
12040                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12041                   {
12042                     tree arg = TREE_VALUE (p);
12043                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12044                       arg = TREE_TYPE (arg);
12045
12046                     /* This lets bad template code slip through.  */
12047                     if (IS_AGGR_TYPE (arg)
12048                         || TREE_CODE (arg) == ENUMERAL_TYPE
12049                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12050                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12051                       goto foundaggr;
12052                   }
12053               cp_error
12054                 ("`%D' must have an argument of class or enumerated type",
12055                  decl);
12056             foundaggr:
12057               ;
12058             }
12059         }
12060
12061       if (name == ansi_opname[(int) CALL_EXPR])
12062         return;                 /* No restrictions on args. */
12063
12064       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12065         {
12066           tree t = TREE_TYPE (name);
12067           if (! friendp)
12068             {
12069               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12070               const char *what = 0;
12071
12072               if (ref)
12073                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12074
12075               if (TREE_CODE (t) == VOID_TYPE)
12076                 what = "void";
12077               else if (t == current_class_type)
12078                 what = "the same type";
12079               /* Don't force t to be complete here.  */
12080               else if (IS_AGGR_TYPE (t)
12081                        && TYPE_SIZE (t)
12082                        && DERIVED_FROM_P (t, current_class_type))
12083                 what = "a base class";
12084
12085               if (what)
12086                 warning ("conversion to %s%s will never use a type conversion operator",
12087                          ref ? "a reference to " : "", what);
12088             }
12089         }
12090
12091       if (name == ansi_opname[(int) MODIFY_EXPR])
12092         {
12093           tree parmtype;
12094
12095           if (list_length (argtypes) != 3 && methodp)
12096             {
12097               cp_error ("`%D' must take exactly one argument", decl);
12098               return;
12099             }
12100           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12101
12102           if (copy_assignment_arg_p (parmtype, virtualp)
12103               && ! friendp)
12104             {
12105               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12106               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12107                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12108                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12109             }
12110         }
12111       else if (name == ansi_opname[(int) COND_EXPR])
12112         {
12113           /* 13.4.0.3 */
12114           cp_error ("ISO C++ prohibits overloading operator ?:");
12115         }
12116       else if (ambi_op_p (name))
12117         {
12118           if (list_length (argtypes) == 2)
12119             /* prefix */;
12120           else if (list_length (argtypes) == 3)
12121             {
12122               if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
12123                    || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12124                   && ! processing_template_decl
12125                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12126                 {
12127                   if (methodp)
12128                     cp_error ("postfix `%D' must take `int' as its argument",
12129                               decl);
12130                   else
12131                     cp_error
12132                       ("postfix `%D' must take `int' as its second argument",
12133                        decl);
12134                 }
12135             }
12136           else
12137             {
12138               if (methodp)
12139                 cp_error ("`%D' must take either zero or one argument", decl);
12140               else
12141                 cp_error ("`%D' must take either one or two arguments", decl);
12142             }
12143
12144           /* More Effective C++ rule 6.  */
12145           if (warn_ecpp
12146               && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12147                   || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
12148             {
12149               tree arg = TREE_VALUE (argtypes);
12150               tree ret = TREE_TYPE (TREE_TYPE (decl));
12151               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12152                 arg = TREE_TYPE (arg);
12153               arg = TYPE_MAIN_VARIANT (arg);
12154               if (list_length (argtypes) == 2)
12155                 {
12156                   if (TREE_CODE (ret) != REFERENCE_TYPE
12157                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12158                                        arg))
12159                     cp_warning ("prefix `%D' should return `%T'", decl,
12160                                 build_reference_type (arg));
12161                 }
12162               else
12163                 {
12164                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12165                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12166                 }
12167             }
12168         }
12169       else if (unary_op_p (name))
12170         {
12171           if (list_length (argtypes) != 2)
12172             {
12173               if (methodp)
12174                 cp_error ("`%D' must take `void'", decl);
12175               else
12176                 cp_error ("`%D' must take exactly one argument", decl);
12177             }
12178         }
12179       else /* if (binary_op_p (name)) */
12180         {
12181           if (list_length (argtypes) != 3)
12182             {
12183               if (methodp)
12184                 cp_error ("`%D' must take exactly one argument", decl);
12185               else
12186                 cp_error ("`%D' must take exactly two arguments", decl);
12187             }
12188
12189           /* More Effective C++ rule 7.  */
12190           if (warn_ecpp
12191               && (name == ansi_opname [TRUTH_ANDIF_EXPR]
12192                   || name == ansi_opname [TRUTH_ORIF_EXPR]
12193                   || name == ansi_opname [COMPOUND_EXPR]))
12194             cp_warning ("user-defined `%D' always evaluates both arguments",
12195                         decl);
12196         }
12197
12198       /* Effective C++ rule 23.  */
12199       if (warn_ecpp
12200           && list_length (argtypes) == 3
12201           && (name == ansi_opname [PLUS_EXPR]
12202               || name == ansi_opname [MINUS_EXPR]
12203               || name == ansi_opname [TRUNC_DIV_EXPR]
12204               || name == ansi_opname [MULT_EXPR])
12205           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12206         cp_warning ("`%D' should return by value", decl);
12207
12208       /* 13.4.0.8 */
12209       if (argtypes)
12210         for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
12211           if (TREE_PURPOSE (argtypes))
12212             {
12213               TREE_PURPOSE (argtypes) = NULL_TREE;
12214               if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12215                   || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12216                 {
12217                   if (pedantic)
12218                     cp_pedwarn ("`%D' cannot have default arguments", decl);
12219                 }
12220               else
12221                 cp_error ("`%D' cannot have default arguments", decl);
12222             }
12223     }
12224 }
12225 \f
12226 static const char *
12227 tag_name (code)
12228      enum tag_types code;
12229 {
12230   switch (code)
12231     {
12232     case record_type:
12233       return "struct";
12234     case class_type:
12235       return "class";
12236     case union_type:
12237       return "union ";
12238     case enum_type:
12239       return "enum";
12240     default:
12241       my_friendly_abort (981122);
12242     }
12243 }
12244
12245 /* Get the struct, enum or union (CODE says which) with tag NAME.
12246    Define the tag as a forward-reference if it is not defined.
12247
12248    C++: If a class derivation is given, process it here, and report
12249    an error if multiple derivation declarations are not identical.
12250
12251    If this is a definition, come in through xref_tag and only look in
12252    the current frame for the name (since C++ allows new names in any
12253    scope.)  */
12254
12255 tree
12256 xref_tag (code_type_node, name, globalize)
12257      tree code_type_node;
12258      tree name;
12259      int globalize;
12260 {
12261   enum tag_types tag_code;
12262   enum tree_code code;
12263   register tree ref, t;
12264   struct binding_level *b = current_binding_level;
12265   int got_type = 0;
12266   tree attributes = NULL_TREE;
12267   tree context = NULL_TREE;
12268
12269   /* If we are called from the parser, code_type_node will sometimes be a
12270      TREE_LIST.  This indicates that the user wrote
12271      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12272      use them later.  */
12273   if (TREE_CODE (code_type_node) == TREE_LIST)
12274     {
12275       attributes = TREE_PURPOSE (code_type_node);
12276       code_type_node = TREE_VALUE (code_type_node);
12277     }
12278
12279   tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12280   switch (tag_code)
12281     {
12282     case record_type:
12283     case class_type:
12284       code = RECORD_TYPE;
12285       break;
12286     case union_type:
12287       code = UNION_TYPE;
12288       break;
12289     case enum_type:
12290       code = ENUMERAL_TYPE;
12291       break;
12292     default:
12293       my_friendly_abort (18);
12294     }
12295
12296   /* If a cross reference is requested, look up the type
12297      already defined for this tag and return it.  */
12298   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
12299     {
12300       t = name;
12301       name = TYPE_IDENTIFIER (t);
12302       got_type = 1;
12303     }
12304   else
12305     t = IDENTIFIER_TYPE_VALUE (name);
12306
12307   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12308       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12309     t = NULL_TREE;
12310
12311   if (! globalize)
12312     {
12313       /* If we know we are defining this tag, only look it up in
12314          this scope and don't try to find it as a type.  */
12315       ref = lookup_tag (code, name, b, 1);
12316     }
12317   else
12318     {
12319       if (t)
12320         {
12321           /* [dcl.type.elab] If the identifier resolves to a
12322              typedef-name or a template type-parameter, the
12323              elaborated-type-specifier is ill-formed.  */
12324           if (t != TYPE_MAIN_VARIANT (t)
12325               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12326             cp_pedwarn ("using typedef-name `%D' after `%s'",
12327                         TYPE_NAME (t), tag_name (tag_code));
12328           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12329             cp_error ("using template type parameter `%T' after `%s'",
12330                       t, tag_name (tag_code));
12331
12332           ref = t;
12333         }
12334       else
12335         ref = lookup_tag (code, name, b, 0);
12336
12337       if (! ref)
12338         {
12339           /* Try finding it as a type declaration.  If that wins,
12340              use it.  */
12341           ref = lookup_name (name, 1);
12342
12343           if (ref != NULL_TREE
12344               && processing_template_decl
12345               && DECL_CLASS_TEMPLATE_P (ref)
12346               && template_class_depth (current_class_type) == 0)
12347             /* Since GLOBALIZE is true, we're declaring a global
12348                template, so we want this type.  */
12349             ref = DECL_RESULT (ref);
12350
12351           if (ref && TREE_CODE (ref) == TYPE_DECL
12352               && TREE_CODE (TREE_TYPE (ref)) == code)
12353             ref = TREE_TYPE (ref);
12354           else
12355             ref = NULL_TREE;
12356         }
12357
12358       if (ref && current_class_type
12359           && template_class_depth (current_class_type)
12360           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12361         {
12362           /* Since GLOBALIZE is non-zero, we are not looking at a
12363              definition of this tag.  Since, in addition, we are currently
12364              processing a (member) template declaration of a template
12365              class, we must be very careful; consider:
12366
12367                template <class X>
12368                struct S1
12369
12370                template <class U>
12371                struct S2
12372                { template <class V>
12373                friend struct S1; };
12374
12375              Here, the S2::S1 declaration should not be confused with the
12376              outer declaration.  In particular, the inner version should
12377              have a template parameter of level 2, not level 1.  This
12378              would be particularly important if the member declaration
12379              were instead:
12380
12381                template <class V = U> friend struct S1;
12382
12383              say, when we should tsubst into `U' when instantiating
12384              S2.  On the other hand, when presented with:
12385
12386                  template <class T>
12387                  struct S1 {
12388                    template <class U>
12389                    struct S2 {};
12390                    template <class U>
12391                    friend struct S2;
12392                  };
12393
12394               we must find the inner binding eventually.  We
12395               accomplish this by making sure that the new type we
12396               create to represent this declaration has the right
12397               TYPE_CONTEXT.  */
12398           context = TYPE_CONTEXT (ref);
12399           ref = NULL_TREE;
12400         }
12401     }
12402
12403   if (! ref)
12404     {
12405       /* If no such tag is yet defined, create a forward-reference node
12406          and record it as the "definition".
12407          When a real declaration of this type is found,
12408          the forward-reference will be altered into a real type.  */
12409       if (code == ENUMERAL_TYPE)
12410         {
12411           cp_error ("use of enum `%#D' without previous declaration", name);
12412
12413           ref = make_node (ENUMERAL_TYPE);
12414
12415           /* Give the type a default layout like unsigned int
12416              to avoid crashing if it does not get defined.  */
12417           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12418           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12419           TREE_UNSIGNED (ref) = 1;
12420           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12421           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12422           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12423
12424           /* Enable us to recognize when a type is created in class context.
12425              To do nested classes correctly, this should probably be cleared
12426              out when we leave this classes scope.  Currently this in only
12427              done in `start_enum'.  */
12428
12429           pushtag (name, ref, globalize);
12430         }
12431       else
12432         {
12433           struct binding_level *old_b = class_binding_level;
12434
12435           ref = make_aggr_type (code);
12436           TYPE_CONTEXT (ref) = context;
12437
12438 #ifdef NONNESTED_CLASSES
12439           /* Class types don't nest the way enums do.  */
12440           class_binding_level = (struct binding_level *)0;
12441 #endif
12442           pushtag (name, ref, globalize);
12443           class_binding_level = old_b;
12444         }
12445     }
12446   else
12447     {
12448       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12449         redeclare_class_template (ref, current_template_parms);
12450     }
12451
12452   /* Until the type is defined, tentatively accept whatever
12453      structure tag the user hands us.  */
12454   if (TYPE_SIZE (ref) == NULL_TREE
12455       && ref != current_class_type
12456       /* Have to check this, in case we have contradictory tag info.  */
12457       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12458     {
12459       if (tag_code == class_type)
12460         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12461       else if (tag_code == record_type)
12462         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12463     }
12464
12465   TREE_TYPE (ref) = attributes;
12466
12467   return ref;
12468 }
12469
12470 tree
12471 xref_tag_from_type (old, id, globalize)
12472      tree old, id;
12473      int globalize;
12474 {
12475   tree code_type_node;
12476
12477   if (TREE_CODE (old) == RECORD_TYPE)
12478     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12479                       ? class_type_node : record_type_node);
12480   else
12481     code_type_node = union_type_node;
12482
12483   if (id == NULL_TREE)
12484     id = TYPE_IDENTIFIER (old);
12485
12486   return xref_tag (code_type_node, id, globalize);
12487 }
12488
12489 /* REF is a type (named NAME), for which we have just seen some
12490    baseclasses.  BINFO is a list of those baseclasses; the
12491    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12492    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12493    struct, or union.  */
12494
12495 void
12496 xref_basetypes (code_type_node, name, ref, binfo)
12497      tree code_type_node;
12498      tree name, ref;
12499      tree binfo;
12500 {
12501   /* In the declaration `A : X, Y, ... Z' we mark all the types
12502      (A, X, Y, ..., Z) so we can check for duplicates.  */
12503   tree binfos;
12504   tree base;
12505
12506   int i, len;
12507   enum tag_types tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12508
12509   if (tag_code == union_type)
12510     {
12511       cp_error ("derived union `%T' invalid", ref);
12512       return;
12513     }
12514
12515   len = list_length (binfo);
12516
12517   /* First, make sure that any templates in base-classes are
12518      instantiated.  This ensures that if we call ourselves recursively
12519      we do not get confused about which classes are marked and which
12520      are not.  */
12521   for (base = binfo; base; base = TREE_CHAIN (base))
12522     complete_type (TREE_VALUE (base));
12523
12524   SET_CLASSTYPE_MARKED (ref);
12525   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12526
12527   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12528     {
12529       /* The base of a derived struct is public by default.  */
12530       int via_public
12531         = (TREE_PURPOSE (binfo) == access_public_node
12532            || TREE_PURPOSE (binfo) == access_public_virtual_node
12533            || (tag_code != class_type
12534                && (TREE_PURPOSE (binfo) == access_default_node
12535                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12536       int via_protected
12537         = (TREE_PURPOSE (binfo) == access_protected_node
12538            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12539       int via_virtual
12540         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12541            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12542            || TREE_PURPOSE (binfo) == access_public_virtual_node
12543            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12544       tree basetype = TREE_VALUE (binfo);
12545       tree base_binfo;
12546
12547       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12548         basetype = TREE_TYPE (basetype);
12549       if (!basetype
12550           || (TREE_CODE (basetype) != RECORD_TYPE
12551               && TREE_CODE (basetype) != TYPENAME_TYPE
12552               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12553               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12554         {
12555           cp_error ("base type `%T' fails to be a struct or class type",
12556                     TREE_VALUE (binfo));
12557           continue;
12558         }
12559
12560       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12561
12562       /* This code replaces similar code in layout_basetypes.
12563          We put the complete_type first for implicit `typename'.  */
12564       if (TYPE_SIZE (basetype) == NULL_TREE
12565           && ! (current_template_parms && uses_template_parms (basetype)))
12566         {
12567           cp_error ("base class `%T' has incomplete type", basetype);
12568           continue;
12569         }
12570       else
12571         {
12572           if (CLASSTYPE_MARKED (basetype))
12573             {
12574               if (basetype == ref)
12575                 cp_error ("recursive type `%T' undefined", basetype);
12576               else
12577                 cp_error ("duplicate base type `%T' invalid", basetype);
12578               continue;
12579             }
12580
12581           if (TYPE_FOR_JAVA (basetype)
12582               && (current_lang_stack
12583                   == &VARRAY_TREE (current_lang_base, 0)))
12584             TYPE_FOR_JAVA (ref) = 1;
12585
12586           /* Note that the BINFO records which describe individual
12587              inheritances are *not* shared in the lattice!  They
12588              cannot be shared because a given baseclass may be
12589              inherited with different `accessibility' by different
12590              derived classes.  (Each BINFO record describing an
12591              individual inheritance contains flags which say what
12592              the `accessibility' of that particular inheritance is.)  */
12593
12594           base_binfo
12595             = make_binfo (size_zero_node, basetype,
12596                           CLASS_TYPE_P (basetype)
12597                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12598                           CLASS_TYPE_P (basetype)
12599                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12600
12601           TREE_VEC_ELT (binfos, i) = base_binfo;
12602           TREE_VIA_PUBLIC (base_binfo) = via_public;
12603           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12604           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12605           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12606
12607           /* We need to unshare the binfos now so that lookups during class
12608              definition work.  */
12609           unshare_base_binfos (base_binfo);
12610
12611           SET_CLASSTYPE_MARKED (basetype);
12612
12613           /* We are free to modify these bits because they are meaningless
12614              at top level, and BASETYPE is a top-level type.  */
12615           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12616             {
12617               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12618               /* Converting to a virtual base class requires looking
12619                  up the offset of the virtual base.  */
12620               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12621             }
12622
12623           if (CLASS_TYPE_P (basetype))
12624             {
12625               TYPE_HAS_NEW_OPERATOR (ref)
12626                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12627               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12628                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12629               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12630               /* If the base-class uses multiple inheritance, so do we.  */
12631               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12632                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12633               /* Likewise, if converting to a base of the base may require
12634                  code, then we may need to generate code to convert to a
12635                  base as well.  */
12636               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12637                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12638             }
12639
12640           i += 1;
12641         }
12642     }
12643   if (i)
12644     TREE_VEC_LENGTH (binfos) = i;
12645   else
12646     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12647
12648   if (i > 1)
12649     {
12650       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12651       /* If there is more than one non-empty they cannot be at the same
12652          address.  */
12653       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12654     }
12655
12656   /* Unmark all the types.  */
12657   while (--i >= 0)
12658     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12659   CLEAR_CLASSTYPE_MARKED (ref);
12660
12661   /* Now that we know all the base-classes, set up the list of virtual
12662      bases.  */
12663   get_vbase_types (ref);
12664 }
12665
12666 \f
12667 /* Begin compiling the definition of an enumeration type.
12668    NAME is its name (or null if anonymous).
12669    Returns the type object, as yet incomplete.
12670    Also records info about it so that build_enumerator
12671    may be used to declare the individual values as they are read.  */
12672
12673 tree
12674 start_enum (name)
12675      tree name;
12676 {
12677   register tree enumtype = NULL_TREE;
12678   struct binding_level *b = current_binding_level;
12679
12680   /* If this is the real definition for a previous forward reference,
12681      fill in the contents in the same object that used to be the
12682      forward reference.  */
12683
12684   if (name != NULL_TREE)
12685     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12686
12687   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12688     {
12689       cp_error ("multiple definition of `%#T'", enumtype);
12690       cp_error_at ("previous definition here", enumtype);
12691       /* Clear out TYPE_VALUES, and start again.  */
12692       TYPE_VALUES (enumtype) = NULL_TREE;
12693     }
12694   else
12695     {
12696       enumtype = make_node (ENUMERAL_TYPE);
12697       pushtag (name, enumtype, 0);
12698     }
12699
12700   if (current_class_type)
12701     TREE_ADDRESSABLE (b->tags) = 1;
12702
12703   GNU_xref_decl (current_function_decl, enumtype);
12704   return enumtype;
12705 }
12706
12707 /* After processing and defining all the values of an enumeration type,
12708    install their decls in the enumeration type and finish it off.
12709    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12710    Returns ENUMTYPE.  */
12711
12712 tree
12713 finish_enum (enumtype)
12714      tree enumtype;
12715 {
12716   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12717   /* Calculate the maximum value of any enumerator in this type.  */
12718
12719   tree values = TYPE_VALUES (enumtype);
12720   if (values)
12721     {
12722       tree pair;
12723
12724       for (pair = values; pair; pair = TREE_CHAIN (pair))
12725         {
12726           tree decl;
12727           tree value;
12728
12729           /* The TREE_VALUE is a CONST_DECL for this enumeration
12730              constant.  */
12731           decl = TREE_VALUE (pair);
12732
12733           /* [dcl.enum]
12734
12735              Following the closing brace of an enum-specifier, each
12736              enumerator has the type of its enumeration.  Prior to the
12737              closing brace, the type of each enumerator is the type of
12738              its initializing value.  */
12739           TREE_TYPE (decl) = enumtype;
12740
12741           /* The DECL_INITIAL will be NULL if we are processing a
12742              template declaration and this enumeration constant had no
12743              explicit initializer.  */
12744           value = DECL_INITIAL (decl);
12745           if (value && !processing_template_decl)
12746             {
12747               /* Set the TREE_TYPE for the VALUE as well.  That's so
12748                  that when we call decl_constant_value we get an
12749                  entity of the right type (but with the constant
12750                  value).  Since we shouldn't ever call
12751                  decl_constant_value on a template type, there's no
12752                  reason to do that when processing_template_decl.
12753                  And, if the expression is something like a
12754                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12755                  wreak havoc on the intended type of the expression.
12756
12757                  Of course, there's also no point in trying to compute
12758                  minimum or maximum values if we're in a template.  */
12759               TREE_TYPE (value) = enumtype;
12760
12761               if (!minnode)
12762                 minnode = maxnode = value;
12763               else if (tree_int_cst_lt (maxnode, value))
12764                 maxnode = value;
12765               else if (tree_int_cst_lt (value, minnode))
12766                 minnode = value;
12767             }
12768
12769           if (processing_template_decl)
12770             /* If this is just a template, leave the CONST_DECL
12771                alone.  That way tsubst_copy will find CONST_DECLs for
12772                CONST_DECLs, and not INTEGER_CSTs.  */
12773             ;
12774           else
12775             /* In the list we're building up, we want the enumeration
12776                values, not the CONST_DECLs.  */
12777             TREE_VALUE (pair) = value;
12778         }
12779     }
12780   else
12781     maxnode = minnode = integer_zero_node;
12782
12783   TYPE_VALUES (enumtype) = nreverse (values);
12784
12785   if (processing_template_decl)
12786     {
12787       tree scope = current_scope ();
12788       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12789         add_tree (build_min (TAG_DEFN, enumtype));
12790     }
12791   else
12792     {
12793       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12794       int lowprec = min_precision (minnode, unsignedp);
12795       int highprec = min_precision (maxnode, unsignedp);
12796       int precision = MAX (lowprec, highprec);
12797       tree tem;
12798
12799       TYPE_SIZE (enumtype) = NULL_TREE;
12800
12801       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12802
12803       TYPE_PRECISION (enumtype) = precision;
12804       if (unsignedp)
12805         fixup_unsigned_type (enumtype);
12806       else
12807         fixup_signed_type (enumtype);
12808
12809       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12810         /* Use the width of the narrowest normal C type which is wide
12811            enough.  */
12812         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12813                                                     (precision, 1));
12814       else
12815         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12816
12817       TYPE_SIZE (enumtype) = 0;
12818       layout_type (enumtype);
12819
12820       /* Fix up all variant types of this enum type.  */
12821       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12822            tem = TYPE_NEXT_VARIANT (tem))
12823         {
12824           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12825           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12826           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12827           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12828           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12829           TYPE_MODE (tem) = TYPE_MODE (enumtype);
12830           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12831           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12832           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12833         }
12834
12835       /* Finish debugging output for this type.  */
12836       rest_of_type_compilation (enumtype, namespace_bindings_p ());
12837     }
12838
12839   return enumtype;
12840 }
12841
12842 /* Build and install a CONST_DECL for an enumeration constant of the
12843    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12844    Assignment of sequential values by default is handled here.  */
12845
12846 void
12847 build_enumerator (name, value, enumtype)
12848      tree name;
12849      tree value;
12850      tree enumtype;
12851 {
12852   tree decl;
12853   tree context;
12854   tree type;
12855   tree values;
12856
12857   /* Remove no-op casts from the value.  */
12858   if (value)
12859     STRIP_TYPE_NOPS (value);
12860
12861   if (! processing_template_decl)
12862     {
12863       /* Validate and default VALUE.  */
12864       if (value != NULL_TREE)
12865         {
12866           if (TREE_READONLY_DECL_P (value))
12867             value = decl_constant_value (value);
12868
12869           if (TREE_CODE (value) == INTEGER_CST)
12870             {
12871               value = default_conversion (value);
12872               constant_expression_warning (value);
12873             }
12874           else
12875             {
12876               cp_error ("enumerator value for `%D' not integer constant", name);
12877               value = NULL_TREE;
12878             }
12879         }
12880
12881       /* Default based on previous value.  */
12882       if (value == NULL_TREE && ! processing_template_decl)
12883         {
12884           tree prev_value;
12885
12886           if (TYPE_VALUES (enumtype))
12887             {
12888               /* The next value is the previous value ... */
12889               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
12890               /* ... plus one.  */
12891               value = build_binary_op (PLUS_EXPR,
12892                                        prev_value,
12893                                        integer_one_node);
12894
12895               if (tree_int_cst_lt (value, prev_value))
12896                 cp_error ("overflow in enumeration values at `%D'", name);
12897             }
12898           else
12899             value = integer_zero_node;
12900         }
12901
12902       /* Remove no-op casts from the value.  */
12903       if (value)
12904         STRIP_TYPE_NOPS (value);
12905 #if 0
12906       /* To fix MAX_VAL enum consts. (bkoz)  */
12907       TREE_TYPE (value) = integer_type_node;
12908 #endif
12909     }
12910
12911   /* We always have to copy here; not all INTEGER_CSTs are unshared.
12912      Even in other cases, we will later (in finish_enum) be setting
12913      the type of VALUE.  But, we don't need to make a copy if this
12914      VALUE is one of the enumeration constants for this same
12915      enumeration type.  */
12916   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
12917     if (TREE_VALUE (values) == value)
12918       break;
12919   /* If we didn't break out of the loop, then we do need a copy.  */
12920   if (!values && value)
12921     value = copy_node (value);
12922
12923   /* C++ associates enums with global, function, or class declarations.  */
12924   context = current_scope ();
12925
12926   /* Build the actual enumeration constant.  Note that the enumeration
12927     constants have the type of their initializers until the
12928     enumeration is complete:
12929
12930       [ dcl.enum ]
12931
12932       Following the closing brace of an enum-specifier, each enumer-
12933       ator has the type of its enumeration.  Prior to the closing
12934       brace, the type of each enumerator is the type of its
12935       initializing value.
12936
12937     In finish_enum we will reset the type.  Of course, if we're
12938     processing a template, there may be no value.   */
12939   type = value ? TREE_TYPE (value) : NULL_TREE;
12940
12941   if (context && context == current_class_type)
12942     /* This enum declaration is local to the class.  We need the full
12943       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
12944     decl = build_lang_decl (CONST_DECL, name, type);
12945   else
12946     /* It's a global enum, or it's local to a function.  (Note local to
12947       a function could mean local to a class method.  */
12948     decl = build_decl (CONST_DECL, name, type);
12949
12950   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
12951   DECL_INITIAL (decl) = value;
12952   TREE_READONLY (decl) = 1;
12953
12954   if (context && context == current_class_type)
12955     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12956       on the TYPE_FIELDS list for `S'.  (That's so that you can say
12957       things like `S::i' later.)  */
12958     finish_member_declaration (decl);
12959   else
12960     {
12961       pushdecl (decl);
12962       GNU_xref_decl (current_function_decl, decl);
12963     }
12964
12965   /* Add this enumeration constant to the list for this type.  */
12966   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
12967 }
12968
12969 \f
12970 static int function_depth;
12971
12972 /* We're defining DECL.  Make sure that it's type is OK.  */
12973
12974 static void
12975 check_function_type (decl)
12976      tree decl;
12977 {
12978   tree fntype = TREE_TYPE (decl);
12979
12980   /* In a function definition, arg types must be complete.  */
12981   require_complete_types_for_parms (current_function_parms);
12982
12983   if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
12984     {
12985       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
12986
12987       /* Make it return void instead, but don't change the
12988          type of the DECL_RESULT, in case we have a named return value.  */
12989       if (TREE_CODE (fntype) == METHOD_TYPE)
12990         {
12991           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
12992           TREE_TYPE (decl)
12993             = build_cplus_method_type (ctype,
12994                                        void_type_node,
12995                                        FUNCTION_ARG_CHAIN (decl));
12996         }
12997       else
12998         TREE_TYPE (decl)
12999           = build_function_type (void_type_node,
13000                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13001       TREE_TYPE (decl)
13002         = build_exception_variant (fntype,
13003                                    TYPE_RAISES_EXCEPTIONS (fntype));
13004     }
13005   else
13006     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13007 }
13008
13009 /* Create the FUNCTION_DECL for a function definition.
13010    DECLSPECS and DECLARATOR are the parts of the declaration;
13011    they describe the function's name and the type it returns,
13012    but twisted together in a fashion that parallels the syntax of C.
13013
13014    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13015    DECLARATOR is really the DECL for the function we are about to
13016    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13017    indicating that the function is an inline defined in-class, and
13018    SF_EXPAND indicating that we should generate RTL for this
13019    function.
13020
13021    This function creates a binding context for the function body
13022    as well as setting up the FUNCTION_DECL in current_function_decl.
13023
13024    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13025    (it defines a datum instead), we return 0, which tells
13026    yyparse to report a parse error.
13027
13028    For C++, we must first check whether that datum makes any sense.
13029    For example, "class A local_a(1,2);" means that variable local_a
13030    is an aggregate of type A, which should have a constructor
13031    applied to it with the argument list [1, 2].  */
13032
13033 int
13034 start_function (declspecs, declarator, attrs, flags)
13035      tree declspecs, declarator, attrs;
13036      int flags;
13037 {
13038   tree decl1;
13039   tree ctype = NULL_TREE;
13040   tree fntype;
13041   tree restype;
13042   extern int have_extern_spec;
13043   extern int used_extern_spec;
13044   int doing_friend = 0;
13045   struct binding_level *bl;
13046
13047   /* Sanity check.  */
13048   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13049   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13050
13051   /* This should only be done once on the top most decl.  */
13052   if (have_extern_spec && !used_extern_spec)
13053     {
13054       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13055       used_extern_spec = 1;
13056     }
13057
13058   if (flags & SF_PRE_PARSED)
13059     {
13060       decl1 = declarator;
13061
13062       fntype = TREE_TYPE (decl1);
13063       if (TREE_CODE (fntype) == METHOD_TYPE)
13064         ctype = TYPE_METHOD_BASETYPE (fntype);
13065
13066       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13067          the (lexical) scope of the class in which it is defined.  */
13068       if (!ctype && DECL_FRIEND_P (decl1))
13069         {
13070           ctype = DECL_FRIEND_CONTEXT (decl1);
13071
13072           /* CTYPE could be null here if we're dealing with a template;
13073              for example, `inline friend float foo()' inside a template
13074              will have no CTYPE set.  */
13075           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13076             ctype = NULL_TREE;
13077           else
13078             doing_friend = 1;
13079         }
13080
13081       last_function_parms = DECL_ARGUMENTS (decl1);
13082       last_function_parm_tags = NULL_TREE;
13083     }
13084   else
13085     {
13086       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13087       /* If the declarator is not suitable for a function definition,
13088          cause a syntax error.  */
13089       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13090
13091       fntype = TREE_TYPE (decl1);
13092
13093       restype = TREE_TYPE (fntype);
13094       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13095         {
13096           cp_error ("semicolon missing after declaration of `%#T'", restype);
13097           shadow_tag (build_tree_list (NULL_TREE, restype));
13098           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13099           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13100             fntype = build_function_type (integer_type_node,
13101                                           TYPE_ARG_TYPES (fntype));
13102           else
13103             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13104                                               integer_type_node,
13105                                               TYPE_ARG_TYPES (fntype));
13106           TREE_TYPE (decl1) = fntype;
13107         }
13108
13109       if (TREE_CODE (fntype) == METHOD_TYPE)
13110         ctype = TYPE_METHOD_BASETYPE (fntype);
13111       else if (DECL_MAIN_P (decl1))
13112         {
13113           /* If this doesn't return integer_type, complain.  */
13114           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13115             {
13116               if (pedantic || warn_return_type)
13117                 pedwarn ("return type for `main' changed to `int'");
13118               TREE_TYPE (decl1) = fntype = default_function_type;
13119             }
13120         }
13121     }
13122
13123   /* Sometimes we don't notice that a function is a static member, and
13124      build a METHOD_TYPE for it.  Fix that up now.  */
13125   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13126       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13127     {
13128       revert_static_member_fn (&decl1, NULL, NULL);
13129       last_function_parms = TREE_CHAIN (last_function_parms);
13130       ctype = NULL_TREE;
13131     }
13132
13133   /* Warn if function was previously implicitly declared
13134      (but not if we warned then).  */
13135   if (! warn_implicit
13136       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13137     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13138
13139   /* Set up current_class_type, and enter the scope of the class, if
13140      appropriate.  */
13141   if (ctype)
13142     push_nested_class (ctype, 1);
13143   else if (DECL_STATIC_FUNCTION_P (decl1))
13144     push_nested_class (DECL_CONTEXT (decl1), 2);
13145
13146   /* Now that we have entered the scope of the class, we must restore
13147      the bindings for any template parameters surrounding DECL1, if it
13148      is an inline member template.  (Order is important; consider the
13149      case where a template parameter has the same name as a field of
13150      the class.)  It is not until after this point that
13151      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13152   if (flags & SF_INCLASS_INLINE)
13153     maybe_begin_member_template_processing (decl1);
13154
13155   /* Effective C++ rule 15.  See also c_expand_return.  */
13156   if (warn_ecpp
13157       && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
13158       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13159     cp_warning ("`operator=' should return a reference to `*this'");
13160
13161   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13162      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13163   if (!DECL_INITIAL (decl1))
13164     DECL_INITIAL (decl1) = error_mark_node;
13165
13166 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13167   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13168 #endif
13169
13170   /* This function exists in static storage.
13171      (This does not mean `static' in the C sense!)  */
13172   TREE_STATIC (decl1) = 1;
13173
13174   /* We must call push_template_decl after current_class_type is set
13175      up.  (If we are processing inline definitions after exiting a
13176      class scope, current_class_type will be NULL_TREE until set above
13177      by push_nested_class.)  */
13178   if (processing_template_decl)
13179     decl1 = push_template_decl (decl1);
13180
13181   /* We are now in the scope of the function being defined.  */
13182   current_function_decl = decl1;
13183
13184   /* Save the parm names or decls from this function's declarator
13185      where store_parm_decls will find them.  */
13186   current_function_parms = last_function_parms;
13187   current_function_parm_tags = last_function_parm_tags;
13188
13189   /* Make sure the parameter and return types are reasonable.  When
13190      you declare a function, these types can be incomplete, but they
13191      must be complete when you define the function.  */
13192   if (! processing_template_decl)
13193     check_function_type (decl1);
13194
13195   /* Build the return declaration for the function.  */
13196   restype = TREE_TYPE (fntype);
13197   if (!processing_template_decl)
13198     {
13199       if (!DECL_RESULT (decl1))
13200         {
13201           DECL_RESULT (decl1)
13202             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13203           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13204                                       DECL_RESULT (decl1));
13205         }
13206     }
13207   else
13208     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13209     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13210
13211   /* Initialize RTL machinery.  We cannot do this until
13212      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13213      even when processing a template; this is how we get
13214      CFUN set up, and our per-function variables initialized.  */
13215   bl = current_binding_level;
13216   init_function_start (decl1, input_filename, lineno);
13217   current_binding_level = bl;
13218   expanding_p = (flags & SF_EXPAND) != 0;
13219
13220   /* Even though we're inside a function body, we still don't want to
13221      call expand_expr to calculate the size of a variable-sized array.
13222      We haven't necessarily assigned RTL to all variables yet, so it's
13223      not safe to try to expand expressions involving them.  */
13224   immediate_size_expand = 0;
13225   cfun->x_dont_save_pending_sizes_p = 1;
13226
13227   /* If we're building a statement-tree, start the tree now.  */
13228   if (processing_template_decl || !expanding_p)
13229     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13230
13231   /* Let the user know we're compiling this function.  */
13232   if (processing_template_decl || !building_stmt_tree ())
13233     announce_function (decl1);
13234
13235   /* Record the decl so that the function name is defined.
13236      If we already have a decl for this name, and it is a FUNCTION_DECL,
13237      use the old decl.  */
13238   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13239     {
13240       /* A specialization is not used to guide overload resolution.  */
13241       if ((flag_guiding_decls
13242            || !DECL_TEMPLATE_SPECIALIZATION (decl1))
13243           && ! DECL_FUNCTION_MEMBER_P (decl1))
13244         decl1 = pushdecl (decl1);
13245       else
13246         {
13247           /* We need to set the DECL_CONTEXT. */
13248           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13249             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13250           /* And make sure we have enough default args.  */
13251           check_default_args (decl1);
13252         }
13253       DECL_MAIN_VARIANT (decl1) = decl1;
13254       fntype = TREE_TYPE (decl1);
13255     }
13256
13257   /* Reset these in case the call to pushdecl changed them.  */
13258   current_function_decl = decl1;
13259   cfun->decl = decl1;
13260
13261   /* Initialize the per-function data.  */
13262   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13263     {
13264       /* If we already parsed this function, and we're just expanding it
13265          now, restore saved state.  */
13266       struct binding_level *bl = current_binding_level;
13267       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13268       current_binding_level = bl;
13269
13270       /* This function is being processed in whole-function mode; we
13271          already did semantic analysis.  */
13272       cfun->x_whole_function_mode_p = 1;
13273
13274       /* If we decided that we didn't want to inline this function,
13275          make sure the back-end knows that.  */
13276       if (!current_function_cannot_inline)
13277         current_function_cannot_inline = cp_function_chain->cannot_inline;
13278
13279       /* We don't need the saved data anymore.  */
13280       free (DECL_SAVED_FUNCTION_DATA (decl1));
13281       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13282     }
13283   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13284     {
13285       /* We know that this was set up by `grokclassfn'.  We do not
13286          wait until `store_parm_decls', since evil parse errors may
13287          never get us to that point.  Here we keep the consistency
13288          between `current_class_type' and `current_class_ptr'.  */
13289       tree t = DECL_ARGUMENTS (decl1);
13290
13291       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13292                           162);
13293       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13294                           19990811);
13295
13296       cp_function_chain->x_current_class_ref
13297         = build_indirect_ref (t, NULL_PTR);
13298       cp_function_chain->x_current_class_ptr = t;
13299
13300       /* Constructors and destructors need to know whether they're "in
13301          charge" of initializing virtual base classes.  */
13302       if (DECL_DESTRUCTOR_P (decl1))
13303         current_in_charge_parm = TREE_CHAIN (t);
13304       else if (DECL_CONSTRUCTOR_P (decl1)
13305                && TREE_CHAIN (t)
13306                && DECL_ARTIFICIAL (TREE_CHAIN (t))
13307                && (DECL_NAME (TREE_CHAIN (t))
13308                    == in_charge_identifier))
13309         current_in_charge_parm = TREE_CHAIN (t);
13310     }
13311
13312   if (DECL_INTERFACE_KNOWN (decl1))
13313     {
13314       tree ctx = decl_function_context (decl1);
13315
13316       if (DECL_NOT_REALLY_EXTERN (decl1))
13317         DECL_EXTERNAL (decl1) = 0;
13318
13319       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13320           && TREE_PUBLIC (ctx))
13321         /* This is a function in a local class in an extern inline
13322            function.  */
13323         comdat_linkage (decl1);
13324     }
13325   /* If this function belongs to an interface, it is public.
13326      If it belongs to someone else's interface, it is also external.
13327      This only affects inlines and template instantiations.  */
13328   else if (interface_unknown == 0
13329            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13330                || flag_alt_external_templates))
13331     {
13332       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13333           || processing_template_decl)
13334         {
13335           DECL_EXTERNAL (decl1)
13336             = (interface_only
13337                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13338                    && !DECL_VINDEX (decl1)));
13339
13340           /* For WIN32 we also want to put these in linkonce sections.  */
13341           maybe_make_one_only (decl1);
13342         }
13343       else
13344         DECL_EXTERNAL (decl1) = 0;
13345       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13346       DECL_INTERFACE_KNOWN (decl1) = 1;
13347     }
13348   else if (interface_unknown && interface_only
13349            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13350                || flag_alt_external_templates))
13351     {
13352       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13353          interface, we will have interface_only set but not
13354          interface_known.  In that case, we don't want to use the normal
13355          heuristics because someone will supply a #pragma implementation
13356          elsewhere, and deducing it here would produce a conflict.  */
13357       comdat_linkage (decl1);
13358       DECL_EXTERNAL (decl1) = 0;
13359       DECL_INTERFACE_KNOWN (decl1) = 1;
13360       DECL_DEFER_OUTPUT (decl1) = 1;
13361     }
13362   else
13363     {
13364       /* This is a definition, not a reference.
13365          So clear DECL_EXTERNAL.  */
13366       DECL_EXTERNAL (decl1) = 0;
13367
13368       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13369           && ! DECL_INTERFACE_KNOWN (decl1)
13370           /* Don't try to defer nested functions for now.  */
13371           && ! decl_function_context (decl1))
13372         DECL_DEFER_OUTPUT (decl1) = 1;
13373       else
13374         DECL_INTERFACE_KNOWN (decl1) = 1;
13375     }
13376
13377   if (doing_semantic_analysis_p ())
13378     {
13379       pushlevel (0);
13380       current_binding_level->parm_flag = 1;
13381     }
13382
13383   if (attrs)
13384     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13385
13386   if (!building_stmt_tree ())
13387     {
13388       GNU_xref_function (decl1, current_function_parms);
13389       make_function_rtl (decl1);
13390     }
13391
13392   /* Promote the value to int before returning it.  */
13393   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13394     restype = type_promotes_to (restype);
13395
13396   /* If this fcn was already referenced via a block-scope `extern' decl
13397      (or an implicit decl), propagate certain information about the usage.  */
13398   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13399     TREE_ADDRESSABLE (decl1) = 1;
13400
13401   if (DECL_RESULT (decl1) == NULL_TREE)
13402     {
13403       DECL_RESULT (decl1)
13404         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13405       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13406       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13407     }
13408
13409   ++function_depth;
13410
13411   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
13412       && DECL_LANGUAGE (decl1) == lang_cplusplus)
13413     {
13414       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13415       DECL_CONTEXT (dtor_label) = current_function_decl;
13416     }
13417   else if (DECL_CONSTRUCTOR_P (decl1))
13418     {
13419       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13420       DECL_CONTEXT (ctor_label) = current_function_decl;
13421     }
13422
13423   return 1;
13424 }
13425 \f
13426 /* Called after store_parm_decls for a function-try-block.  */
13427
13428 void
13429 expand_start_early_try_stmts ()
13430 {
13431   expand_start_try_stmts ();
13432 }
13433
13434 /* Store the parameter declarations into the current function declaration.
13435    This is called after parsing the parameter declarations, before
13436    digesting the body of the function.
13437
13438    Also install to binding contour return value identifier, if any.  */
13439
13440 void
13441 store_parm_decls ()
13442 {
13443   register tree fndecl = current_function_decl;
13444   register tree parm;
13445   int parms_have_cleanups = 0;
13446   tree cleanups = NULL_TREE;
13447
13448   /* This is a list of types declared among parms in a prototype.  */
13449   tree parmtags = current_function_parm_tags;
13450
13451   /* This is a chain of any other decls that came in among the parm
13452      declarations.  If a parm is declared with  enum {foo, bar} x;
13453      then CONST_DECLs for foo and bar are put here.  */
13454   tree nonparms = NULL_TREE;
13455
13456   /* Create a binding level for the parms.  */
13457   if (!building_stmt_tree ())
13458     expand_start_bindings (2);
13459
13460   if (current_function_parms)
13461     {
13462       /* This case is when the function was defined with an ANSI prototype.
13463          The parms already have decls, so we need not do anything here
13464          except record them as in effect
13465          and complain if any redundant old-style parm decls were written.  */
13466
13467       tree specparms = current_function_parms;
13468       tree next;
13469
13470       if (doing_semantic_analysis_p ())
13471         {
13472           /* Must clear this because it might contain TYPE_DECLs declared
13473              at class level.  */
13474           storedecls (NULL_TREE);
13475
13476           /* If we're doing semantic analysis, then we'll call pushdecl
13477              for each of these.  We must do them in reverse order so that
13478              they end in the correct forward order.  */
13479           specparms = nreverse (specparms);
13480         }
13481
13482       for (parm = specparms; parm; parm = next)
13483         {
13484           next = TREE_CHAIN (parm);
13485           if (TREE_CODE (parm) == PARM_DECL)
13486             {
13487               tree type = TREE_TYPE (parm);
13488
13489               if (doing_semantic_analysis_p ())
13490                 {
13491                   tree cleanup;
13492
13493                   if (DECL_NAME (parm) == NULL_TREE
13494                       || TREE_CODE (parm) != VOID_TYPE)
13495                     pushdecl (parm);
13496                   else
13497                     cp_error ("parameter `%D' declared void", parm);
13498
13499                   cleanup = (processing_template_decl
13500                              ? NULL_TREE
13501                              : maybe_build_cleanup (parm));
13502
13503                   if (cleanup)
13504                     cleanups = tree_cons (parm, cleanup, cleanups);
13505                 }
13506               else if (type != error_mark_node
13507                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13508                 parms_have_cleanups = 1;
13509             }
13510           else
13511             {
13512               /* If we find an enum constant or a type tag,
13513                  put it aside for the moment.  */
13514               TREE_CHAIN (parm) = NULL_TREE;
13515               nonparms = chainon (nonparms, parm);
13516             }
13517         }
13518
13519       if (doing_semantic_analysis_p ())
13520         {
13521           /* Get the decls in their original chain order
13522              and record in the function.  This is all and only the
13523              PARM_DECLs that were pushed into scope by the loop above.  */
13524           DECL_ARGUMENTS (fndecl) = getdecls ();
13525           storetags (chainon (parmtags, gettags ()));
13526         }
13527     }
13528   else
13529     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13530
13531   /* Now store the final chain of decls for the arguments
13532      as the decl-chain of the current lexical scope.
13533      Put the enumerators in as well, at the front so that
13534      DECL_ARGUMENTS is not modified.  */
13535   if (doing_semantic_analysis_p ())
13536     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13537
13538   /* Initialize the RTL code for the function.  */
13539   DECL_SAVED_INSNS (fndecl) = 0;
13540   if (! building_stmt_tree ())
13541     expand_function_start (fndecl, parms_have_cleanups);
13542
13543   current_function_parms_stored = 1;
13544
13545   /* If this function is `main', emit a call to `__main'
13546      to run global initializers, etc.  */
13547   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13548     expand_main_function ();
13549
13550   /* Now that we have initialized the parms, we can start their
13551      cleanups.  We cannot do this before, since expand_decl_cleanup
13552      should not be called before the parm can be used.  */
13553   while (cleanups)
13554     {
13555       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13556                            TREE_VALUE (cleanups));
13557       cleanups = TREE_CHAIN (cleanups);
13558     }
13559
13560   /* Create a binding contour which can be used to catch
13561      cleanup-generated temporaries.  Also, if the return value needs or
13562      has initialization, deal with that now.  */
13563   if (parms_have_cleanups)
13564     {
13565       pushlevel (0);
13566       if (!building_stmt_tree ())
13567         expand_start_bindings (2);
13568     }
13569
13570   /* Do the starting of the exception specifications, if we have any.  */
13571   if (flag_exceptions && !processing_template_decl
13572       && flag_enforce_eh_specs
13573       && building_stmt_tree ()
13574       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13575     current_eh_spec_try_block = expand_start_eh_spec ();
13576 }
13577
13578 /* Bind a name and initialization to the return value of
13579    the current function.  */
13580
13581 void
13582 store_return_init (decl)
13583      tree decl;
13584 {
13585   /* If this named return value comes in a register, put it in a
13586      pseudo-register.  */
13587   if (DECL_REGISTER (decl))
13588     {
13589       original_result_rtx = DECL_RTL (decl);
13590       /* Note that the mode of the old DECL_RTL may be wider than the
13591          mode of DECL_RESULT, depending on the calling conventions for
13592          the processor.  For example, on the Alpha, a 32-bit integer
13593          is returned in a DImode register -- the DECL_RESULT has
13594          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
13595          here, we use the mode the back-end has already assigned for
13596          the return value.  */
13597       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13598     }
13599 }
13600
13601 \f
13602 /* We have finished doing semantic analysis on DECL, but have not yet
13603    generated RTL for its body.  Save away our current state, so that
13604    when we want to generate RTL later we know what to do.  */
13605
13606 static void
13607 save_function_data (decl)
13608      tree decl;
13609 {
13610   struct language_function *f;
13611
13612   /* Save the language-specific per-function data so that we can
13613      get it back when we really expand this function.  */
13614   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13615                       19990908);
13616
13617   /* Make a copy.  */
13618   f = ((struct language_function *)
13619        xmalloc (sizeof (struct language_function)));
13620   bcopy ((char *) cp_function_chain, (char *) f,
13621          sizeof (struct language_function));
13622   DECL_SAVED_FUNCTION_DATA (decl) = f;
13623
13624   /* Clear out the bits we don't need.  */
13625   f->x_base_init_list = NULL_TREE;
13626   f->x_member_init_list = NULL_TREE;
13627   f->x_stmt_tree.x_last_stmt = NULL_TREE;
13628   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
13629   f->x_result_rtx = NULL_RTX;
13630   f->x_named_label_uses = NULL;
13631   f->bindings = NULL;
13632
13633   /* When we get back here again, we will be expanding.  */
13634   f->x_expanding_p = 1;
13635
13636   /* If we've already decided that we cannot inline this function, we
13637      must remember that fact when we actually go to expand the
13638      function.  */
13639   f->cannot_inline = current_function_cannot_inline;
13640 }
13641
13642 /* At the end of every constructor we generate to code to return
13643    `this'.  Do that now.  */
13644
13645 static void
13646 finish_constructor_body ()
13647 {
13648   /* Any return from a constructor will end up here.  */
13649   add_tree (build_min_nt (LABEL_STMT, ctor_label));
13650
13651   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13652      generate the return, rather than a goto to CTOR_LABEL.  */
13653   ctor_label = NULL_TREE;
13654   /* In check_return_expr we translate an empty return from a
13655      constructor to a return of `this'.  */
13656   finish_return_stmt (NULL_TREE);
13657   /* Mark the end of the constructor.  */
13658   add_tree (build_min_nt (CTOR_STMT));
13659 }
13660
13661 /* At the end of every destructor we generate code to restore virtual
13662    function tables to the values desired by base classes and to call
13663    to base class destructors.  Do that now.  */
13664
13665 static void
13666 finish_destructor_body ()
13667 {
13668   tree compound_stmt;
13669   tree in_charge;
13670   tree virtual_size;
13671   tree exprstmt;
13672
13673   /* Create a block to contain all the extra code.  */
13674   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13675
13676   /* Any return from a destructor will end up here.  */
13677   add_tree (build_min_nt (LABEL_STMT, dtor_label));
13678
13679   /* Generate the code to call destructor on base class.  If this
13680      destructor belongs to a class with virtual functions, then set
13681      the virtual function table pointer to represent the type of our
13682      base class.  */
13683
13684   /* This side-effect makes call to `build_delete' generate the code
13685      we have to have at the end of this destructor.  `build_delete'
13686      will set the flag again.  */
13687   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13688
13689   /* These are two cases where we cannot delegate deletion.  */
13690   if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
13691       || TYPE_GETS_REG_DELETE (current_class_type))
13692     in_charge = integer_zero_node;
13693   else
13694     in_charge = current_in_charge_parm;
13695
13696   exprstmt = build_delete (current_class_type,
13697                            current_class_ref,
13698                            in_charge,
13699                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13700                            0);
13701
13702   if (exprstmt != error_mark_node
13703       && (TREE_CODE (exprstmt) != NOP_EXPR
13704           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13705           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13706     {
13707       if (exprstmt != void_zero_node)
13708         /* Don't call `expand_expr_stmt' if we're not going to do
13709            anything, since -Wall will give a diagnostic.  */
13710         finish_expr_stmt (exprstmt);
13711
13712       /* Run destructors for all virtual baseclasses.  */
13713       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13714         {
13715           tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
13716           tree if_stmt = begin_if_stmt ();
13717           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13718                                       current_in_charge_parm,
13719                                       integer_two_node),
13720                                if_stmt);
13721
13722           while (vbases)
13723             {
13724               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbases)))
13725                 {
13726                   tree vb = get_vbase
13727                     (BINFO_TYPE (vbases),
13728                      TYPE_BINFO (current_class_type));
13729                   finish_expr_stmt
13730                     (build_scoped_method_call
13731                      (current_class_ref, vb, dtor_identifier,
13732                       build_tree_list (NULL_TREE, integer_zero_node)));
13733                 }
13734               vbases = TREE_CHAIN (vbases);
13735             }
13736
13737           finish_then_clause (if_stmt);
13738           finish_if_stmt ();
13739         }
13740     }
13741
13742   virtual_size = c_sizeof (current_class_type);
13743
13744   /* At the end, call delete if that's what's requested.  */
13745
13746   /* FDIS sez: At the point of definition of a virtual destructor
13747      (including an implicit definition), non-placement operator delete
13748      shall be looked up in the scope of the destructor's class and if
13749      found shall be accessible and unambiguous.
13750
13751      This is somewhat unclear, but I take it to mean that if the class
13752      only defines placement deletes we don't do anything here.  So we
13753      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13754      they ever try to delete one of these.  */
13755   if (TYPE_GETS_REG_DELETE (current_class_type)
13756       || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13757     {
13758       tree if_stmt;
13759
13760       exprstmt = build_op_delete_call
13761         (DELETE_EXPR, current_class_ptr, virtual_size,
13762          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13763
13764       if_stmt = begin_if_stmt ();
13765       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13766                                   current_in_charge_parm,
13767                                   integer_one_node),
13768                            if_stmt);
13769       finish_expr_stmt (exprstmt);
13770       finish_then_clause (if_stmt);
13771       finish_if_stmt ();
13772     }
13773
13774   /* Close the block we started above.  */
13775   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13776 }
13777
13778 /* Finish up a function declaration and compile that function
13779    all the way to assembler language output.  The free the storage
13780    for the function definition.
13781
13782    This is called after parsing the body of the function definition.
13783    LINENO is the current line number.
13784
13785    FLAGS is a bitwise or of the following values:
13786      1 - CALL_POPLEVEL
13787        An extra call to poplevel (and expand_end_bindings) must be
13788        made to take care of the binding contour for the base
13789        initializers.  This is only relevant for constructors.
13790      2 - INCLASS_INLINE
13791        We just finished processing the body of an in-class inline
13792        function definition.  (This processing will have taken place
13793        after the class definition is complete.)  */
13794
13795 tree
13796 finish_function (lineno, flags)
13797      int lineno;
13798      int flags;
13799 {
13800   register tree fndecl = current_function_decl;
13801   tree fntype, ctype = NULL_TREE;
13802   /* Label to use if this function is supposed to return a value.  */
13803   tree no_return_label = NULL_TREE;
13804   int call_poplevel = (flags & 1) != 0;
13805   int inclass_inline = (flags & 2) != 0;
13806   int expand_p;
13807   int nested;
13808
13809   /* When we get some parse errors, we can end up without a
13810      current_function_decl, so cope.  */
13811   if (fndecl == NULL_TREE)
13812     return error_mark_node;
13813
13814   nested = function_depth > 1;
13815   fntype = TREE_TYPE (fndecl);
13816
13817   /*  TREE_READONLY (fndecl) = 1;
13818       This caused &foo to be of type ptr-to-const-function
13819       which then got a warning when stored in a ptr-to-function variable.  */
13820
13821   /* This happens on strange parse errors.  */
13822   if (! current_function_parms_stored)
13823     {
13824       call_poplevel = 0;
13825       store_parm_decls ();
13826     }
13827
13828   if (building_stmt_tree ())
13829     {
13830       if (DECL_CONSTRUCTOR_P (fndecl))
13831         {
13832           finish_constructor_body ();
13833           if (call_poplevel)
13834             do_poplevel ();
13835         }
13836       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13837         finish_destructor_body ();
13838       else if (DECL_MAIN_P (fndecl))
13839         {
13840           /* Make it so that `main' always returns 0 by default.  */
13841 #ifdef VMS
13842           finish_return_stmt (integer_one_node);
13843 #else
13844           finish_return_stmt (integer_zero_node);
13845 #endif
13846         }
13847
13848       /* Finish dealing with exception specifiers.  */
13849       if (flag_exceptions && !processing_template_decl
13850           && flag_enforce_eh_specs
13851           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13852         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13853                             (TREE_TYPE (current_function_decl)),
13854                             current_eh_spec_try_block);
13855     }
13856   else
13857     {
13858 #if 0
13859       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13860         {
13861           /* Keep this code around in case we later want to control debug info
13862              based on whether a type is "used".  (jason 1999-11-11) */
13863
13864           tree ttype = target_type (fntype);
13865           tree parmdecl;
13866
13867           if (IS_AGGR_TYPE (ttype))
13868             /* Let debugger know it should output info for this type.  */
13869             note_debug_info_needed (ttype);
13870
13871           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
13872             {
13873               ttype = target_type (TREE_TYPE (parmdecl));
13874               if (IS_AGGR_TYPE (ttype))
13875                 /* Let debugger know it should output info for this type.  */
13876                 note_debug_info_needed (ttype);
13877             }
13878         }
13879 #endif
13880
13881       /* Clean house because we will need to reorder insns here.  */
13882       do_pending_stack_adjust ();
13883
13884       if (dtor_label)
13885         ;
13886       else if (DECL_CONSTRUCTOR_P (fndecl))
13887         {
13888           if (call_poplevel)
13889             do_poplevel ();
13890         }
13891       else if (return_label != NULL_RTX
13892                && flag_this_is_variable <= 0
13893                && current_function_return_value == NULL_TREE
13894                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
13895         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13896
13897       if (flag_exceptions)
13898         expand_exception_blocks ();
13899
13900       /* If this function is supposed to return a value, ensure that
13901          we do not fall into the cleanups by mistake.  The end of our
13902          function will look like this:
13903
13904          user code (may have return stmt somewhere)
13905          goto no_return_label
13906          cleanup_label:
13907          cleanups
13908          goto return_label
13909          no_return_label:
13910          NOTE_INSN_FUNCTION_END
13911          return_label:
13912          things for return
13913
13914          If the user omits a return stmt in the USER CODE section, we
13915          will have a control path which reaches NOTE_INSN_FUNCTION_END.
13916          Otherwise, we won't.  */
13917       if (no_return_label)
13918         {
13919           DECL_CONTEXT (no_return_label) = fndecl;
13920           DECL_INITIAL (no_return_label) = error_mark_node;
13921           DECL_SOURCE_FILE (no_return_label) = input_filename;
13922           DECL_SOURCE_LINE (no_return_label) = lineno;
13923           expand_goto (no_return_label);
13924         }
13925
13926       if (cleanup_label)
13927         {
13928           /* Remove the binding contour which is used
13929              to catch cleanup-generated temporaries.  */
13930           expand_end_bindings (0, 0, 0);
13931           poplevel (0, 0, 0);
13932
13933           /* Emit label at beginning of cleanup code for parameters.  */
13934           emit_label (cleanup_label);
13935         }
13936
13937       /* Get return value into register if that's where it's supposed
13938          to be.  */
13939       if (original_result_rtx)
13940         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
13941
13942       /* Finish building code that will trigger warnings if users forget
13943          to make their functions return values.  */
13944       if (no_return_label || cleanup_label)
13945         emit_jump (return_label);
13946       if (no_return_label)
13947         {
13948           /* We don't need to call `expand_*_return' here because we
13949              don't need any cleanups here--this path of code is only
13950              for error checking purposes.  */
13951           expand_label (no_return_label);
13952         }
13953
13954       /* We hard-wired immediate_size_expand to zero in
13955          start_function.  Expand_function_end will decrement this
13956          variable.  So, we set the variable to one here, so that after
13957          the decrement it will remain zero.  */
13958       immediate_size_expand = 1;
13959
13960       /* Generate rtl for function exit.  */
13961       expand_function_end (input_filename, lineno, 1);
13962     }
13963
13964   /* We have to save this value here in case
13965      maybe_end_member_template_processing decides to pop all the
13966      template parameters.  */
13967   expand_p = !building_stmt_tree ();
13968
13969   /* If we're saving up tree structure, tie off the function now.  */
13970   if (!expand_p)
13971     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13972
13973   /* This must come after expand_function_end because cleanups might
13974      have declarations (from inline functions) that need to go into
13975      this function's blocks.  */
13976   if (doing_semantic_analysis_p ())
13977     {
13978       if (current_binding_level->parm_flag != 1)
13979         my_friendly_abort (122);
13980       poplevel (1, 0, 1);
13981     }
13982
13983   /* Remember that we were in class scope.  */
13984   if (current_class_name)
13985     ctype = current_class_type;
13986
13987   /* Must mark the RESULT_DECL as being in this function.  */
13988   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13989
13990   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13991      to the FUNCTION_DECL node itself.  */
13992   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13993
13994   /* Save away current state, if appropriate.  */
13995   if (!expanding_p && !processing_template_decl)
13996     save_function_data (fndecl);
13997
13998   /* If this function calls `setjmp' it cannot be inlined.  When
13999      `longjmp' is called it is not guaranteed to restore the value of
14000      local variables that have been modified since the call to
14001      `setjmp'.  So, if were to inline this function into some caller
14002      `c', then when we `longjmp', we might not restore all variables
14003      in `c'.  (It might seem, at first blush, that there's no way for
14004      this function to modify local variables in `c', but their
14005      addresses may have been stored somewhere accessible to this
14006      function.)  */
14007   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14008     DECL_UNINLINABLE (fndecl) = 1;
14009
14010   if (expand_p)
14011     {
14012       int returns_null;
14013       int returns_value;
14014
14015       /* So we can tell if jump_optimize sets it to 1.  */
14016       can_reach_end = 0;
14017
14018       /* Before we call rest_of_compilation (which will pop the
14019          CURRENT_FUNCTION), we must save these values.  */
14020       returns_null = current_function_returns_null;
14021       returns_value = current_function_returns_value;
14022
14023       /* If this is a nested function (like a template instantiation
14024          that we're compiling in the midst of compiling something
14025          else), push a new GC context.  That will keep local variables
14026          on the stack from being collected while we're doing the
14027          compilation of this function.  */
14028       if (function_depth > 1)
14029         ggc_push_context ();
14030
14031       /* Run the optimizers and output the assembler code for this
14032          function.  */
14033       if (DECL_ARTIFICIAL (fndecl))
14034         {
14035           /* Do we really *want* to inline this synthesized method?  */
14036
14037           int save_fif = flag_inline_functions;
14038           flag_inline_functions = 1;
14039
14040           /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
14041              will check our size.  */
14042           DECL_INLINE (fndecl) = 0;
14043
14044           rest_of_compilation (fndecl);
14045           flag_inline_functions = save_fif;
14046         }
14047       else
14048         rest_of_compilation (fndecl);
14049
14050       /* Undo the call to ggc_push_context above.  */
14051       if (function_depth > 1)
14052         ggc_pop_context ();
14053
14054       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14055         {
14056           /* Set DECL_EXTERNAL so that assemble_external will be called as
14057              necessary.  We'll clear it again in finish_file.  */
14058           if (! DECL_EXTERNAL (fndecl))
14059             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14060           DECL_EXTERNAL (fndecl) = 1;
14061           mark_inline_for_output (fndecl);
14062         }
14063
14064 #if 0
14065       /* Keep this code around in case we later want to control debug info
14066          based on whether a type is "used".  (jason 1999-11-11) */
14067
14068       if (ctype && TREE_ASM_WRITTEN (fndecl))
14069         note_debug_info_needed (ctype);
14070 #endif
14071
14072       returns_null |= can_reach_end;
14073
14074       /* Since we don't normally go through c_expand_return for constructors,
14075          this normally gets the wrong value.
14076          Also, named return values have their return codes emitted after
14077          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
14078       if (DECL_CONSTRUCTOR_P (fndecl)
14079           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
14080         returns_null = 0;
14081
14082       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14083         cp_warning ("`noreturn' function `%D' does return", fndecl);
14084       else if ((warn_return_type || pedantic)
14085                && returns_null
14086                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14087         {
14088           /* If this function returns non-void and control can drop through,
14089              complain.  */
14090           cp_warning ("control reaches end of non-void function `%D'", fndecl);
14091         }
14092       /* With just -W, complain only if function returns both with
14093          and without a value.  */
14094       else if (extra_warnings && returns_value && returns_null)
14095         warning ("this function may return with or without a value");
14096     }
14097   else
14098     {
14099       /* Clear out memory we no longer need.  */
14100       free_after_parsing (cfun);
14101       /* Since we never call rest_of_compilation, we never clear
14102          CFUN.  Do so explicitly.  */
14103       free_after_compilation (cfun);
14104       cfun = NULL;
14105     }
14106
14107   /* If this is a in-class inline definition, we may have to pop the
14108      bindings for the template parameters that we added in
14109      maybe_begin_member_template_processing when start_function was
14110      called.  */
14111   if (inclass_inline)
14112     maybe_end_member_template_processing ();
14113
14114   /* Leave the scope of the class.  */
14115   if (ctype)
14116     pop_nested_class ();
14117
14118   --function_depth;
14119
14120   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14121       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14122     {
14123       tree t;
14124
14125       /* Stop pointing to the local nodes about to be freed.  */
14126       /* But DECL_INITIAL must remain nonzero so we know this
14127          was an actual function definition.  */
14128       DECL_INITIAL (fndecl) = error_mark_node;
14129       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14130         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14131     }
14132
14133   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14134     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14135   if (DECL_STATIC_DESTRUCTOR (fndecl))
14136     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14137
14138   /* Clean up.  */
14139   if (! nested)
14140     {
14141       /* Let the error reporting routines know that we're outside a
14142          function.  For a nested function, this value is used in
14143          pop_cp_function_context and then reset via pop_function_context.  */
14144       current_function_decl = NULL_TREE;
14145       /* We don't really care about obstacks, but the middle-end
14146          sometimes cares on what obstck things are located.  */
14147       permanent_allocation (1);
14148     }
14149
14150   return fndecl;
14151 }
14152 \f
14153 /* Create the FUNCTION_DECL for a function definition.
14154    DECLSPECS and DECLARATOR are the parts of the declaration;
14155    they describe the return type and the name of the function,
14156    but twisted together in a fashion that parallels the syntax of C.
14157
14158    This function creates a binding context for the function body
14159    as well as setting up the FUNCTION_DECL in current_function_decl.
14160
14161    Returns a FUNCTION_DECL on success.
14162
14163    If the DECLARATOR is not suitable for a function (it defines a datum
14164    instead), we return 0, which tells yyparse to report a parse error.
14165
14166    May return void_type_node indicating that this method is actually
14167    a friend.  See grokfield for more details.
14168
14169    Came here with a `.pushlevel' .
14170
14171    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14172    CHANGES TO CODE IN `grokfield'.  */
14173
14174 tree
14175 start_method (declspecs, declarator, attrlist)
14176      tree declarator, declspecs, attrlist;
14177 {
14178   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14179                                 attrlist);
14180
14181   /* Something too ugly to handle.  */
14182   if (fndecl == NULL_TREE)
14183     return NULL_TREE;
14184
14185   /* Pass friends other than inline friend functions back.  */
14186   if (fndecl == void_type_node)
14187     return fndecl;
14188
14189   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14190     /* Not a function, tell parser to report parse error.  */
14191     return NULL_TREE;
14192
14193   if (DECL_IN_AGGR_P (fndecl))
14194     {
14195       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14196         {
14197           if (DECL_CONTEXT (fndecl)
14198               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14199             cp_error ("`%D' is already defined in class %s", fndecl,
14200                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14201         }
14202       return void_type_node;
14203     }
14204
14205   check_template_shadow (fndecl);
14206
14207   DECL_THIS_INLINE (fndecl) = 1;
14208
14209   if (flag_default_inline)
14210     DECL_INLINE (fndecl) = 1;
14211
14212   /* We process method specializations in finish_struct_1.  */
14213   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14214     fndecl = push_template_decl (fndecl);
14215
14216   /* We read in the parameters on the maybepermanent_obstack,
14217      but we won't be getting back to them until after we
14218      may have clobbered them.  So the call to preserve_data
14219      will keep them safe.  */
14220   preserve_data ();
14221
14222   if (! DECL_FRIEND_P (fndecl))
14223     {
14224       if (TREE_CHAIN (fndecl))
14225         {
14226           fndecl = copy_node (fndecl);
14227           TREE_CHAIN (fndecl) = NULL_TREE;
14228         }
14229
14230       if (DECL_CONSTRUCTOR_P (fndecl))
14231         {
14232           if (! grok_ctor_properties (current_class_type, fndecl))
14233             return void_type_node;
14234         }
14235       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14236         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14237     }
14238
14239   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14240
14241   /* Make a place for the parms */
14242   pushlevel (0);
14243   current_binding_level->parm_flag = 1;
14244
14245   DECL_IN_AGGR_P (fndecl) = 1;
14246   return fndecl;
14247 }
14248
14249 /* Go through the motions of finishing a function definition.
14250    We don't compile this method until after the whole class has
14251    been processed.
14252
14253    FINISH_METHOD must return something that looks as though it
14254    came from GROKFIELD (since we are defining a method, after all).
14255
14256    This is called after parsing the body of the function definition.
14257    STMTS is the chain of statements that makes up the function body.
14258
14259    DECL is the ..._DECL that `start_method' provided.  */
14260
14261 tree
14262 finish_method (decl)
14263      tree decl;
14264 {
14265   register tree fndecl = decl;
14266   tree old_initial;
14267
14268   register tree link;
14269
14270   if (decl == void_type_node)
14271     return decl;
14272
14273   old_initial = DECL_INITIAL (fndecl);
14274
14275   /* Undo the level for the parms (from start_method).
14276      This is like poplevel, but it causes nothing to be
14277      saved.  Saving information here confuses symbol-table
14278      output routines.  Besides, this information will
14279      be correctly output when this method is actually
14280      compiled.  */
14281
14282   /* Clear out the meanings of the local variables of this level;
14283      also record in each decl which block it belongs to.  */
14284
14285   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14286     {
14287       if (DECL_NAME (link) != NULL_TREE)
14288         pop_binding (DECL_NAME (link), link);
14289       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14290       DECL_CONTEXT (link) = NULL_TREE;
14291     }
14292
14293   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14294                       (HOST_WIDE_INT) current_binding_level->level_chain,
14295                       current_binding_level->parm_flag,
14296                       current_binding_level->keep);
14297
14298   poplevel (0, 0, 0);
14299
14300   DECL_INITIAL (fndecl) = old_initial;
14301
14302   /* We used to check if the context of FNDECL was different from
14303      current_class_type as another way to get inside here.  This didn't work
14304      for String.cc in libg++.  */
14305   if (DECL_FRIEND_P (fndecl))
14306     {
14307       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14308         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14309       decl = void_type_node;
14310     }
14311
14312   return decl;
14313 }
14314 \f
14315 /* Called when a new struct TYPE is defined.
14316    If this structure or union completes the type of any previous
14317    variable declaration, lay it out and output its rtl.  */
14318
14319 void
14320 hack_incomplete_structures (type)
14321      tree type;
14322 {
14323   tree *list;
14324   struct binding_level *level;
14325
14326   if (!type) /* Don't do this for class templates.  */
14327     return;
14328
14329   if (namespace_bindings_p ())
14330     {
14331       level = 0;
14332       list = &namespace_scope_incomplete;
14333     }
14334   else
14335     {
14336       level = innermost_nonclass_level ();
14337       list = &level->incomplete;
14338     }
14339
14340   while (1)
14341     {
14342       while (*list)
14343         {
14344           tree decl = TREE_VALUE (*list);
14345           if ((decl && TREE_TYPE (decl) == type)
14346               || (TREE_TYPE (decl)
14347                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14348                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14349             {
14350               int toplevel = toplevel_bindings_p ();
14351               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14352                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14353                 layout_type (TREE_TYPE (decl));
14354               layout_decl (decl, 0);
14355               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14356               if (! toplevel)
14357                 {
14358                   tree cleanup;
14359                   expand_decl (decl);
14360                   cleanup = maybe_build_cleanup (decl);
14361                   expand_decl_init (decl);
14362                   if (! expand_decl_cleanup (decl, cleanup))
14363                     cp_error ("parser lost in parsing declaration of `%D'",
14364                               decl);
14365                 }
14366               *list = TREE_CHAIN (*list);
14367             }
14368           else
14369             list = &TREE_CHAIN (*list);
14370         }
14371
14372       /* Keep looking through artificial binding levels generated
14373          for local variables.  */
14374       if (level && level->keep == 2)
14375         {
14376           level = level->level_chain;
14377           list = &level->incomplete;
14378         }
14379       else
14380         break;
14381     }
14382 }
14383
14384 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14385    See build_delete for information about AUTO_DELETE.
14386
14387    Don't build these on the momentary obstack; they must live
14388    the life of the binding contour.  */
14389
14390 static tree
14391 maybe_build_cleanup_1 (decl, auto_delete)
14392      tree decl, auto_delete;
14393 {
14394   tree type = TREE_TYPE (decl);
14395   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14396     {
14397       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14398       tree rval;
14399
14400       if (TREE_CODE (type) == ARRAY_TYPE)
14401         rval = decl;
14402       else
14403         {
14404           mark_addressable (decl);
14405           rval = build_unary_op (ADDR_EXPR, decl, 0);
14406         }
14407
14408       /* Optimize for space over speed here.  */
14409       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14410           || flag_expensive_optimizations)
14411         flags |= LOOKUP_NONVIRTUAL;
14412
14413       rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
14414
14415       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14416           && ! TYPE_HAS_DESTRUCTOR (type))
14417         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14418                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14419
14420       return rval;
14421     }
14422   return 0;
14423 }
14424
14425 /* If DECL is of a type which needs a cleanup, build that cleanup
14426    here.  The cleanup does free the storage with a call to delete.  */
14427
14428 tree
14429 maybe_build_cleanup_and_delete (decl)
14430      tree decl;
14431 {
14432   return maybe_build_cleanup_1 (decl, integer_three_node);
14433 }
14434
14435 /* If DECL is of a type which needs a cleanup, build that cleanup
14436    here.  The cleanup does not free the storage with a call a delete.  */
14437
14438 tree
14439 maybe_build_cleanup (decl)
14440      tree decl;
14441 {
14442   return maybe_build_cleanup_1 (decl, integer_two_node);
14443 }
14444 \f
14445 /* Expand a C++ expression at the statement level.
14446    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14447    The C++ type checker should get all of these out when
14448    expressions are combined with other, type-providing, expressions,
14449    leaving only orphan expressions, such as:
14450
14451    &class::bar;         / / takes its address, but does nothing with it.  */
14452
14453 void
14454 cplus_expand_expr_stmt (exp)
14455      tree exp;
14456 {
14457   if (stmts_are_full_exprs_p)
14458     exp = convert_to_void (exp, "statement");
14459
14460 #if 0
14461   /* We should do this eventually, but right now this causes regex.o from
14462      libg++ to miscompile, and tString to core dump.  */
14463   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14464 #endif
14465
14466   /* If we don't do this, we end up down inside expand_expr
14467      trying to do TYPE_MODE on the ERROR_MARK, and really
14468      go outside the bounds of the type.  */
14469   if (exp != error_mark_node)
14470     expand_expr_stmt (exp);
14471 }
14472
14473 /* When a stmt has been parsed, this function is called.  */
14474
14475 void
14476 finish_stmt ()
14477 {
14478   /* Always assume this statement was not an expression statement.  If
14479      it actually was an expression statement, its our callers
14480      responsibility to fix this up.  */
14481   last_expr_type = NULL_TREE;
14482 }
14483
14484 /* Change a static member function definition into a FUNCTION_TYPE, instead
14485    of the METHOD_TYPE that we create when it's originally parsed.
14486
14487    WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
14488    (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
14489    other decls.  Either pass the addresses of local variables or NULL.  */
14490
14491 void
14492 revert_static_member_fn (decl, fn, argtypes)
14493      tree *decl, *fn, *argtypes;
14494 {
14495   tree tmp;
14496   tree function = fn ? *fn : TREE_TYPE (*decl);
14497   tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
14498
14499   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14500       != TYPE_UNQUALIFIED)
14501     cp_error ("static member function `%#D' declared with type qualifiers",
14502               *decl);
14503
14504   args = TREE_CHAIN (args);
14505   tmp = build_function_type (TREE_TYPE (function), args);
14506   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14507   tmp = build_exception_variant (tmp,
14508                                  TYPE_RAISES_EXCEPTIONS (function));
14509   TREE_TYPE (*decl) = tmp;
14510   if (DECL_ARGUMENTS (*decl))
14511     DECL_ARGUMENTS (*decl) = TREE_CHAIN (DECL_ARGUMENTS (*decl));
14512   DECL_STATIC_FUNCTION_P (*decl) = 1;
14513   if (fn)
14514     *fn = tmp;
14515   if (argtypes)
14516     *argtypes = args;
14517 }
14518
14519 /* Initialize the variables used during compilation of a C++
14520    function.  */
14521
14522 static void
14523 push_cp_function_context (f)
14524      struct function *f;
14525 {
14526   struct language_function *p
14527     = ((struct language_function *)
14528        xcalloc (1, sizeof (struct language_function)));
14529   f->language = p;
14530
14531   /* It takes an explicit call to expand_body to generate RTL for a
14532      function.  */
14533   expanding_p = 0;
14534
14535   /* Whenever we start a new function, we destroy temporaries in the
14536      usual way.  */
14537   stmts_are_full_exprs_p = 1;
14538 }
14539
14540 /* Free the language-specific parts of F, now that we've finished
14541    compiling the function.  */
14542
14543 static void
14544 pop_cp_function_context (f)
14545      struct function *f;
14546 {
14547   if (f->language)
14548     free (f->language);
14549   f->language = 0;
14550 }
14551
14552 /* Mark P for GC.  */
14553
14554 static void
14555 mark_lang_function (p)
14556      struct language_function *p;
14557 {
14558   if (!p)
14559     return;
14560
14561   ggc_mark_tree (p->x_named_labels);
14562   ggc_mark_tree (p->x_ctor_label);
14563   ggc_mark_tree (p->x_dtor_label);
14564   ggc_mark_tree (p->x_base_init_list);
14565   ggc_mark_tree (p->x_member_init_list);
14566   ggc_mark_tree (p->x_current_class_ptr);
14567   ggc_mark_tree (p->x_current_class_ref);
14568   ggc_mark_tree (p->x_eh_spec_try_block);
14569   ggc_mark_tree (p->x_scope_stmt_stack);
14570
14571   ggc_mark_rtx (p->x_result_rtx);
14572
14573   mark_stmt_tree (&p->x_stmt_tree);
14574   mark_binding_level (&p->bindings);
14575 }
14576
14577 /* Mark the language-specific data in F for GC.  */
14578
14579 static void
14580 mark_cp_function_context (f)
14581      struct function *f;
14582 {
14583   mark_lang_function (f->language);
14584 }
14585
14586 int
14587 in_function_p ()
14588 {
14589   return function_depth != 0;
14590 }
14591
14592
14593 void
14594 lang_mark_false_label_stack (l)
14595      struct label_node *l;
14596 {
14597   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14598   my_friendly_assert (l == NULL, 19990904);
14599 }
14600
14601 void
14602 lang_mark_tree (t)
14603      tree t;
14604 {
14605   enum tree_code code = TREE_CODE (t);
14606   if (code == IDENTIFIER_NODE)
14607     {
14608       struct lang_identifier *li = (struct lang_identifier *) t;
14609       struct lang_id2 *li2 = li->x;
14610       ggc_mark_tree (li->namespace_bindings);
14611       ggc_mark_tree (li->bindings);
14612       ggc_mark_tree (li->class_value);
14613       ggc_mark_tree (li->class_template_info);
14614
14615       if (li2)
14616         {
14617           ggc_mark_tree (li2->label_value);
14618           ggc_mark_tree (li2->implicit_decl);
14619           ggc_mark_tree (li2->error_locus);
14620         }
14621     }
14622   else if (code == CPLUS_BINDING)
14623     {
14624       if (BINDING_HAS_LEVEL_P (t))
14625         mark_binding_level (&BINDING_LEVEL (t));
14626       else
14627         ggc_mark_tree (BINDING_SCOPE (t));
14628       ggc_mark_tree (BINDING_VALUE (t));
14629     }
14630   else if (code == OVERLOAD)
14631     ggc_mark_tree (OVL_FUNCTION (t));
14632   else if (code == TEMPLATE_PARM_INDEX)
14633     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14634   else if (TREE_CODE_CLASS (code) == 'd')
14635     {
14636       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14637
14638       if (ld)
14639         {
14640           ggc_mark (ld);
14641           if (!DECL_GLOBAL_CTOR_P (t) && !DECL_GLOBAL_DTOR_P (t))
14642             ggc_mark_tree (ld->decl_flags.u2.access);
14643           ggc_mark_tree (ld->decl_flags.context);
14644           if (TREE_CODE (t) != NAMESPACE_DECL)
14645             ggc_mark_tree (ld->decl_flags.u.template_info);
14646           else
14647             mark_binding_level (&NAMESPACE_LEVEL (t));
14648           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14649             {
14650               ggc_mark_tree (ld->main_decl_variant);
14651               ggc_mark_tree (ld->befriending_classes);
14652               ggc_mark_tree (ld->saved_tree);
14653               if (TREE_CODE (t) == TYPE_DECL)
14654                 ggc_mark_tree (ld->u.sorted_fields);
14655               else if (TREE_CODE (t) == FUNCTION_DECL
14656                        && !DECL_PENDING_INLINE_P (t))
14657                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14658             }
14659         }
14660     }
14661   else if (TREE_CODE_CLASS (code) == 't')
14662     {
14663       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14664
14665       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14666                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14667         {
14668           ggc_mark (lt);
14669           ggc_mark_tree (lt->vfields);
14670           ggc_mark_tree (lt->vbases);
14671           ggc_mark_tree (lt->tags);
14672           ggc_mark_tree (lt->search_slot);
14673           ggc_mark_tree (lt->size);
14674           ggc_mark_tree (lt->pure_virtuals);
14675           ggc_mark_tree (lt->friend_classes);
14676           ggc_mark_tree (lt->rtti);
14677           ggc_mark_tree (lt->methods);
14678           ggc_mark_tree (lt->template_info);
14679           ggc_mark_tree (lt->befriending_classes);
14680         }
14681       else if (lt)
14682         /* In the case of pointer-to-member function types, the
14683            TYPE_LANG_SPECIFIC is really just a tree.  */
14684         ggc_mark_tree ((tree) lt);
14685     }
14686 }