gcc/cp/decl.c

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