gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "flags.h"
  36 #include "cp-tree.h"
  37 #include "decl.h"
  38 #include "lex.h"
  39 #include <signal.h>
  40 #include "obstack.h"
  41 #include "defaults.h"
  42 #include "output.h"
  43 #include "except.h"
  44 #include "toplev.h"
  45 #include "../hash.h"
  46 #include "defaults.h"
  47 #include "ggc.h"
  48
  49 #define obstack_chunk_alloc xmalloc
  50 #define obstack_chunk_free free
  51
  52 extern struct obstack permanent_obstack;
  53
  54 extern int current_class_depth;
  55
  56 extern tree static_ctors, static_dtors;
  57
  58 extern tree global_namespace;
  59
  60 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  61
  62 /* Use garbage collection.  */
  63
  64 int ggc_p = 1;
  65
  66 #ifndef WCHAR_UNSIGNED
  67 #define WCHAR_UNSIGNED 0
  68 #endif
  69
  70 #ifndef CHAR_TYPE_SIZE
  71 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  72 #endif
  73
  74 #ifndef BOOL_TYPE_SIZE
  75 #ifdef SLOW_BYTE_ACCESS
  76 /* In the new ABI, `bool' has size and alignment `1', on all
  77    platforms.  */
  78 #define BOOL_TYPE_SIZE \
  79   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  80 #else
  81 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  82 #endif
  83 #endif
  84
  85 /* We let tm.h override the types used here, to handle trivial differences
  86    such as the choice of unsigned int or long unsigned int for size_t.
  87    When machines start needing nontrivial differences in the size type,
  88    it would be best to do something here to figure out automatically
  89    from other information what type to use.  */
  90
  91 #ifndef SIZE_TYPE
  92 #define SIZE_TYPE "long unsigned int"
  93 #endif
  94
  95 #ifndef PTRDIFF_TYPE
  96 #define PTRDIFF_TYPE "long int"
  97 #endif
  98
  99 #ifndef WCHAR_TYPE
 100 #define WCHAR_TYPE "int"
 101 #endif
 102
 103 static tree grokparms                           PARAMS ((tree, int));
 104 static const char *redeclaration_error_message  PARAMS ((tree, tree));
 105
 106 static void push_binding_level PARAMS ((struct binding_level *, int,
 107                                       int));
 108 static void pop_binding_level PARAMS ((void));
 109 static void suspend_binding_level PARAMS ((void));
 110 static void resume_binding_level PARAMS ((struct binding_level *));
 111 static struct binding_level *make_binding_level PARAMS ((void));
 112 static void declare_namespace_level PARAMS ((void));
 113 static void signal_catch PARAMS ((int)) ATTRIBUTE_NORETURN;
 114 static void storedecls PARAMS ((tree));
 115 static void require_complete_types_for_parms PARAMS ((tree));
 116 static int ambi_op_p PARAMS ((tree));
 117 static int unary_op_p PARAMS ((tree));
 118 static tree store_bindings PARAMS ((tree, tree));
 119 static tree lookup_tag_reverse PARAMS ((tree, tree));
 120 static tree obscure_complex_init PARAMS ((tree, tree));
 121 static tree maybe_build_cleanup_1 PARAMS ((tree, tree));
 122 static tree lookup_name_real PARAMS ((tree, int, int, int));
 123 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 124 static void grok_reference_init PARAMS ((tree, tree, tree));
 125 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 126                               enum overload_flags, tree,
 127                               tree, int, int, int, int, int, int, tree));
 128 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 129 static tree lookup_tag PARAMS ((enum tree_code, tree,
 130                               struct binding_level *, int));
 131 static void set_identifier_type_value_with_scope
 132         PARAMS ((tree, tree, struct binding_level *));
 133 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 134 static void record_unknown_type PARAMS ((tree, const char *));
 135 static tree build_library_fn_1                  PARAMS ((tree, tree));
 136 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 137 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 138                                   int));
 139 static void lang_print_error_function PARAMS ((const char *));
 140 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 141 static void check_for_uninitialized_const_var PARAMS ((tree));
 142 static unsigned long typename_hash PARAMS ((hash_table_key));
 143 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 144 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 145 static int add_binding PARAMS ((tree, tree));
 146 static void pop_binding PARAMS ((tree, tree));
 147 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 148 static tree find_binding PARAMS ((tree, tree));
 149 static tree select_decl PARAMS ((tree, int));
 150 static int lookup_flags PARAMS ((int, int));
 151 static tree qualify_lookup PARAMS ((tree, int));
 152 static tree record_builtin_java_type PARAMS ((const char *, int));
 153 static const char *tag_name PARAMS ((enum tag_types code));
 154 static void find_class_binding_level PARAMS ((void));
 155 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 156 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 157 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 158 static int walk_globals_r PARAMS ((tree, void *));
 159 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 160 static tree make_label_decl PARAMS ((tree, int));
 161 static void pop_label PARAMS ((tree));
 162 static void pop_labels PARAMS ((tree));
 163 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 164 static void layout_var_decl PARAMS ((tree));
 165 static void maybe_commonize_var PARAMS ((tree));
 166 static tree check_initializer PARAMS ((tree, tree));
 167 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 168 static void push_cp_function_context PARAMS ((struct function *));
 169 static void pop_cp_function_context PARAMS ((struct function *));
 170 static void mark_binding_level PARAMS ((void *));
 171 static void mark_cp_function_context PARAMS ((struct function *));
 172 static void mark_saved_scope PARAMS ((void *));
 173 static void mark_lang_function PARAMS ((struct language_function *));
 174 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 175 static void save_function_data PARAMS ((tree));
 176 static void check_function_type PARAMS ((tree));
 177 static void destroy_local_var PARAMS ((tree));
 178 static void finish_constructor_body PARAMS ((void));
 179 static void finish_destructor_body PARAMS ((void));
 180 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 181 static tree get_atexit_node PARAMS ((void));
 182 static tree get_dso_handle_node PARAMS ((void));
 183 static tree start_cleanup_fn PARAMS ((void));
 184 static void end_cleanup_fn PARAMS ((void));
 185 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 186
 187 #if defined (DEBUG_CP_BINDING_LEVELS)
 188 static void indent PARAMS ((void));
 189 #endif
 190
 191 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 192 tree error_mark_list;
 193
 194 /* The following symbols are subsumed in the cp_global_trees array, and
 195    listed here individually for documentation purposes.
 196
 197    C++ extensions
 198         tree wchar_decl_node;
 199         tree void_zero_node;
 200
 201         tree vtable_entry_type;
 202         tree delta_type_node;
 203 #if 0
 204    Old rtti stuff.
 205         tree __baselist_desc_type_node;
 206         tree __i_desc_type_node, __m_desc_type_node;
 207         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 208 #endif
 209         tree __t_desc_type_node;
 210 #if 0
 211         tree __tp_desc_type_node;
 212 #endif
 213         tree ti_desc_type_node;
 214         tree bltn_desc_type_node, ptr_desc_type_node;
 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    Namespaces,
 235
 236         tree std_node;
 237         tree abi_node;
 238
 239    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 240    one that the user will declare, but sufficient to be called
 241    by routines that want to abort the program.
 242
 243         tree abort_fndecl;
 244
 245    The FUNCTION_DECL for the default `::operator delete'.
 246
 247         tree global_delete_fndecl;
 248
 249    Used by RTTI
 250         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 251         tree tinfo_var_id;
 252
 253 */
 254
 255 tree cp_global_trees[CPTI_MAX];
 256
 257 /* Indicates that there is a type value in some namespace, although
 258    that is not necessarily in scope at the moment.  */
 259
 260 static tree global_type_node;
 261
 262 /* Namespace std.  */
 263 int in_std;
 264
 265 /* Expect only namespace names now. */
 266 static int only_namespace_names;
 267
 268 /* If original DECL_RESULT of current function was a register,
 269    but due to being an addressable named return value, would up
 270    on the stack, this variable holds the named return value's
 271    original location.  */
 272
 273 #define original_result_rtx cp_function_chain->x_result_rtx
 274
 275 struct named_label_list
 276 {
 277   struct binding_level *binding_level;
 278   tree names_in_scope;
 279   tree label_decl;
 280   const char *filename_o_goto;
 281   int lineno_o_goto;
 282   struct named_label_list *next;
 283 };
 284
 285 /* Used only for jumps to as-yet undefined labels, since jumps to
 286    defined labels can have their validity checked by stmt.c.  */
 287
 288 #define named_label_uses cp_function_chain->x_named_label_uses
 289
 290 /* A list of objects which have constructors or destructors
 291    which reside in the global scope.  The decl is stored in
 292    the TREE_VALUE slot and the initializer is stored
 293    in the TREE_PURPOSE slot.  */
 294 tree static_aggregates;
 295
 296 /* -- end of C++ */
 297
 298 /* A node for the integer constants 2, and 3.  */
 299
 300 tree integer_two_node, integer_three_node;
 301
 302 /* Parsing a function declarator leaves here a chain of structure
 303    and enum types declared in the parmlist.  */
 304
 305 static tree last_function_parm_tags;
 306
 307 /* Similar, for last_function_parm_tags.  */
 308 tree last_function_parms;
 309 static tree current_function_parm_tags;
 310
 311 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 312    that have names.  Here so we can clear out their names' definitions
 313    at the end of the function.  The TREE_VALUE is a LABEL_DECL; the
 314    TREE_PURPOSE is the previous binding of the label.  */
 315
 316 #define named_labels cp_function_chain->x_named_labels
 317
 318 /* Set to 0 at beginning of a function definition, and whenever
 319    a label (case or named) is defined.  Set to value of expression
 320    returned from function when that value can be transformed into
 321    a named return value.  */
 322
 323 tree current_function_return_value;
 324
 325 /* Nonzero means use the ISO C99 dialect of C.  */
 326
 327 int flag_isoc99;
 328
 329 /* Nonzero means give `double' the same size as `float'.  */
 330
 331 extern int flag_short_double;
 332
 333 /* Nonzero means don't recognize any builtin functions.  */
 334
 335 extern int flag_no_builtin;
 336
 337 /* Nonzero means don't recognize the non-ANSI builtin functions.
 338    -ansi sets this.  */
 339
 340 extern int flag_no_nonansi_builtin;
 341
 342 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
 343    objects.  */
 344 extern int flag_huge_objects;
 345
 346 /* Nonzero if we want to conserve space in the .o files.  We do this
 347    by putting uninitialized data and runtime initialized data into
 348    .common instead of .data at the expense of not flagging multiple
 349    definitions.  */
 350 extern int flag_conserve_space;
 351 \f
 352 /* C and C++ flags are in decl2.c.  */
 353
 354 /* Flag used when debugging spew.c */
 355
 356 extern int spew_debug;
 357
 358 /* A expression of value 0 with the same precision as a sizetype
 359    node, but signed.  */
 360 tree signed_size_zero_node;
 361
 362 /* The name of the anonymous namespace, throughout this translation
 363    unit.  */
 364 tree anonymous_namespace_name;
 365
 366 \f
 367 /* For each binding contour we allocate a binding_level structure
 368    which records the names defined in that contour.
 369    Contours include:
 370     0) the global one
 371     1) one for each function definition,
 372        where internal declarations of the parameters appear.
 373     2) one for each compound statement,
 374        to record its declarations.
 375
 376    The current meaning of a name can be found by searching the levels
 377    from the current one out to the global one.
 378
 379    Off to the side, may be the class_binding_level.  This exists only
 380    to catch class-local declarations.  It is otherwise nonexistent.
 381
 382    Also there may be binding levels that catch cleanups that must be
 383    run when exceptions occur.  Thus, to see whether a name is bound in
 384    the current scope, it is not enough to look in the
 385    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 386    instead.  */
 387
 388 /* Note that the information in the `names' component of the global contour
 389    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 390
 391 struct binding_level
 392   {
 393     /* A chain of _DECL nodes for all variables, constants, functions,
 394        and typedef types.  These are in the reverse of the order
 395        supplied.  There may be OVERLOADs on this list, too, but they
 396        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 397     tree names;
 398
 399     /* A list of structure, union and enum definitions, for looking up
 400        tag names.
 401        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 402        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 403        or ENUMERAL_TYPE node.
 404
 405        C++: the TREE_VALUE nodes can be simple types for
 406        component_bindings.  */
 407     tree tags;
 408
 409     /* A list of USING_DECL nodes. */
 410     tree usings;
 411
 412     /* A list of used namespaces. PURPOSE is the namespace,
 413        VALUE the common ancestor with this binding_level's namespace. */
 414     tree using_directives;
 415
 416     /* If this binding level is the binding level for a class, then
 417        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 418        is the name of an entity bound in the class; the TREE_VALUE is
 419        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 420        when leaving class scope, we can restore the
 421        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 422        the DECL bound by this name in the class.  */
 423     tree class_shadowed;
 424
 425     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 426        is used for all binding levels.  */
 427     tree type_shadowed;
 428
 429     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 430        label in this scope.  The TREE_PURPOSE is the previous value of
 431        the IDENTIFIER_LABEL VALUE.  */
 432     tree shadowed_labels;
 433
 434     /* For each level (except not the global one),
 435        a chain of BLOCK nodes for all the levels
 436        that were entered and exited one level down.  */
 437     tree blocks;
 438
 439     /* The BLOCK node for this level, if one has been preallocated.
 440        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 441     tree this_block;
 442
 443     /* The _TYPE node for this level, if parm_flag == 2.  */
 444     tree this_class;
 445
 446     /* The binding level which this one is contained in (inherits from).  */
 447     struct binding_level *level_chain;
 448
 449     /* List of decls in `names' that have incomplete
 450        structure or union types.  */
 451     tree incomplete;
 452
 453     /* List of VAR_DECLS saved from a previous for statement.
 454        These would be dead in ISO-conforming code, but might
 455        be referenced in ARM-era code.  These are stored in a
 456        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 457     tree dead_vars_from_for;
 458
 459     /* 1 for the level that holds the parameters of a function.
 460        2 for the level that holds a class declaration.  */
 461     unsigned parm_flag : 2;
 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 : 2;
 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 scope 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 template_parms_p : 1;
 479
 480     /* Nonzero if this scope corresponds to the `<>' in a
 481        `template <>' clause.  Whenever this flag is set,
 482        TEMPLATE_PARMS_P will be set as well.  */
 483     unsigned template_spec_p : 1;
 484
 485     /* This is set for a namespace binding level.  */
 486     unsigned namespace_p : 1;
 487
 488     /* True if this level is that of a for-statement where we need to
 489        worry about ambiguous (ARM or ISO) scope rules.  */
 490     unsigned is_for_scope : 1;
 491
 492     /* True if this level corresponds to an EH region, as for a try block.  */
 493     unsigned eh_region : 1;
 494
 495     /* Four bits left for this word.  */
 496
 497 #if defined(DEBUG_CP_BINDING_LEVELS)
 498     /* Binding depth at which this level began.  */
 499     unsigned binding_depth;
 500 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 501   };
 502
 503 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 504
 505 /* The binding level currently in effect.  */
 506
 507 #define current_binding_level                   \
 508   (cfun                                         \
 509    ? cp_function_chain->bindings                \
 510    : scope_chain->bindings)
 511
 512 /* The binding level of the current class, if any.  */
 513
 514 #define class_binding_level scope_chain->class_bindings
 515
 516 /* A chain of binding_level structures awaiting reuse.  */
 517
 518 static struct binding_level *free_binding_level;
 519
 520 /* The outermost binding level, for names of file scope.
 521    This is created when the compiler is started and exists
 522    through the entire run.  */
 523
 524 static struct binding_level *global_binding_level;
 525
 526 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 527
 528 static int keep_next_level_flag;
 529
 530 #if defined(DEBUG_CP_BINDING_LEVELS)
 531 static int binding_depth = 0;
 532 static int is_class_level = 0;
 533
 534 static void
 535 indent ()
 536 {
 537   register unsigned i;
 538
 539   for (i = 0; i < binding_depth*2; i++)
 540     putc (' ', stderr);
 541 }
 542 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 543
 544 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 545
 546 static void
 547 push_binding_level (newlevel, tag_transparent, keep)
 548      struct binding_level *newlevel;
 549      int tag_transparent, keep;
 550 {
 551   /* Add this level to the front of the chain (stack) of levels that
 552      are active.  */
 553   bzero ((char*) newlevel, sizeof (struct binding_level));
 554   newlevel->level_chain = current_binding_level;
 555   current_binding_level = newlevel;
 556   newlevel->tag_transparent = tag_transparent;
 557   newlevel->more_cleanups_ok = 1;
 558
 559   /* We are called before expand_start_bindings, but after
 560      expand_eh_region_start for a try block; so we check this now,
 561      before the EH block is covered up.  */
 562   newlevel->eh_region = is_eh_region ();
 563
 564   newlevel->keep = keep;
 565 #if defined(DEBUG_CP_BINDING_LEVELS)
 566   newlevel->binding_depth = binding_depth;
 567   indent ();
 568   fprintf (stderr, "push %s level 0x%08x line %d\n",
 569            (is_class_level) ? "class" : "block", newlevel, lineno);
 570   is_class_level = 0;
 571   binding_depth++;
 572 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 573 }
 574
 575 /* Find the innermost enclosing class scope, and reset
 576    CLASS_BINDING_LEVEL appropriately.  */
 577
 578 static void
 579 find_class_binding_level ()
 580 {
 581   struct binding_level *level = current_binding_level;
 582
 583   while (level && level->parm_flag != 2)
 584     level = level->level_chain;
 585   if (level && level->parm_flag == 2)
 586     class_binding_level = level;
 587   else
 588     class_binding_level = 0;
 589 }
 590
 591 static void
 592 pop_binding_level ()
 593 {
 594   if (global_binding_level)
 595     {
 596       /* Cannot pop a level, if there are none left to pop.  */
 597       if (current_binding_level == global_binding_level)
 598         my_friendly_abort (123);
 599     }
 600   /* Pop the current level, and free the structure for reuse.  */
 601 #if defined(DEBUG_CP_BINDING_LEVELS)
 602   binding_depth--;
 603   indent ();
 604   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 605           (is_class_level) ? "class" : "block",
 606           current_binding_level, lineno);
 607   if (is_class_level != (current_binding_level == class_binding_level))
 608     {
 609       indent ();
 610       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 611     }
 612   is_class_level = 0;
 613 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 614   {
 615     register struct binding_level *level = current_binding_level;
 616     current_binding_level = current_binding_level->level_chain;
 617     level->level_chain = free_binding_level;
 618 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 619     if (level->binding_depth != binding_depth)
 620       abort ();
 621 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 622     free_binding_level = level;
 623     find_class_binding_level ();
 624   }
 625 }
 626
 627 static void
 628 suspend_binding_level ()
 629 {
 630   if (class_binding_level)
 631     current_binding_level = class_binding_level;
 632
 633   if (global_binding_level)
 634     {
 635       /* Cannot suspend a level, if there are none left to suspend.  */
 636       if (current_binding_level == global_binding_level)
 637         my_friendly_abort (123);
 638     }
 639   /* Suspend the current level.  */
 640 #if defined(DEBUG_CP_BINDING_LEVELS)
 641   binding_depth--;
 642   indent ();
 643   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 644           (is_class_level) ? "class" : "block",
 645           current_binding_level, lineno);
 646   if (is_class_level != (current_binding_level == class_binding_level))
 647     {
 648       indent ();
 649       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 650     }
 651   is_class_level = 0;
 652 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 653   current_binding_level = current_binding_level->level_chain;
 654   find_class_binding_level ();
 655 }
 656
 657 static void
 658 resume_binding_level (b)
 659      struct binding_level *b;
 660 {
 661   /* Resuming binding levels is meant only for namespaces,
 662      and those cannot nest into classes. */
 663   my_friendly_assert(!class_binding_level, 386);
 664   /* Also, resuming a non-directly nested namespace is a no-no.  */
 665   my_friendly_assert(b->level_chain == current_binding_level, 386);
 666   current_binding_level = b;
 667 #if defined(DEBUG_CP_BINDING_LEVELS)
 668   b->binding_depth = binding_depth;
 669   indent ();
 670   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 671            (is_class_level) ? "class" : "block", b, lineno);
 672   is_class_level = 0;
 673   binding_depth++;
 674 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 675 }
 676 \f
 677 /* Create a new `struct binding_level'.  */
 678
 679 static
 680 struct binding_level *
 681 make_binding_level ()
 682 {
 683   /* NOSTRICT */
 684   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 685 }
 686
 687 /* Nonzero if we are currently in the global binding level.  */
 688
 689 int
 690 global_bindings_p ()
 691 {
 692   return current_binding_level == global_binding_level;
 693 }
 694
 695 /* Return the innermost binding level that is not for a class scope.  */
 696
 697 static struct binding_level *
 698 innermost_nonclass_level ()
 699 {
 700   struct binding_level *b;
 701
 702   b = current_binding_level;
 703   while (b->parm_flag == 2)
 704     b = b->level_chain;
 705
 706   return b;
 707 }
 708
 709 /* Nonzero if we are currently in a toplevel binding level.  This
 710    means either the global binding level or a namespace in a toplevel
 711    binding level.  Since there are no non-toplevel namespace levels,
 712    this really means any namespace or template parameter level.  We
 713    also include a class whose context is toplevel.  */
 714
 715 int
 716 toplevel_bindings_p ()
 717 {
 718   struct binding_level *b = innermost_nonclass_level ();
 719
 720   return b->namespace_p || b->template_parms_p;
 721 }
 722
 723 /* Nonzero if this is a namespace scope, or if we are defining a class
 724    which is itself at namespace scope, or whose enclosing class is
 725    such a class, etc.  */
 726
 727 int
 728 namespace_bindings_p ()
 729 {
 730   struct binding_level *b = innermost_nonclass_level ();
 731
 732   return b->namespace_p;
 733 }
 734
 735 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 736    unconditionally.  Otherwise, use the normal logic to decide whether
 737    or not to create a BLOCK.  */
 738
 739 void
 740 keep_next_level (keep)
 741      int keep;
 742 {
 743   keep_next_level_flag = keep;
 744 }
 745
 746 /* Nonzero if the current level needs to have a BLOCK made.  */
 747
 748 int
 749 kept_level_p ()
 750 {
 751   return (current_binding_level->blocks != NULL_TREE
 752           || current_binding_level->keep
 753           || current_binding_level->names != NULL_TREE
 754           || (current_binding_level->tags != NULL_TREE
 755               && !current_binding_level->tag_transparent));
 756 }
 757
 758 static void
 759 declare_namespace_level ()
 760 {
 761   current_binding_level->namespace_p = 1;
 762 }
 763
 764 /* Returns non-zero if this scope was created to store template
 765    parameters.  */
 766
 767 int
 768 template_parm_scope_p ()
 769 {
 770   return current_binding_level->template_parms_p;
 771 }
 772
 773 /* Returns the kind of template specialization we are currently
 774    processing, given that it's declaration contained N_CLASS_SCOPES
 775    explicit scope qualifications.  */
 776
 777 tmpl_spec_kind
 778 current_tmpl_spec_kind (n_class_scopes)
 779      int n_class_scopes;
 780 {
 781   int n_template_parm_scopes = 0;
 782   int seen_specialization_p = 0;
 783   int innermost_specialization_p = 0;
 784   struct binding_level *b;
 785
 786   /* Scan through the template parameter scopes.  */
 787   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 788     {
 789       /* If we see a specialization scope inside a parameter scope,
 790          then something is wrong.  That corresponds to a declaration
 791          like:
 792
 793             template <class T> template <> ...
 794
 795          which is always illegal since [temp.expl.spec] forbids the
 796          specialization of a class member template if the enclosing
 797          class templates are not explicitly specialized as well.  */
 798       if (b->template_spec_p)
 799         {
 800           if (n_template_parm_scopes == 0)
 801             innermost_specialization_p = 1;
 802           else
 803             seen_specialization_p = 1;
 804         }
 805       else if (seen_specialization_p == 1)
 806         return tsk_invalid_member_spec;
 807
 808       ++n_template_parm_scopes;
 809     }
 810
 811   /* Handle explicit instantiations.  */
 812   if (processing_explicit_instantiation)
 813     {
 814       if (n_template_parm_scopes != 0)
 815         /* We've seen a template parameter list during an explicit
 816            instantiation.  For example:
 817
 818              template <class T> template void f(int);
 819
 820            This is erroneous.  */
 821         return tsk_invalid_expl_inst;
 822       else
 823         return tsk_expl_inst;
 824     }
 825
 826   if (n_template_parm_scopes < n_class_scopes)
 827     /* We've not seen enough template headers to match all the
 828        specialized classes present.  For example:
 829
 830          template <class T> void R<T>::S<T>::f(int);
 831
 832        This is illegal; there needs to be one set of template
 833        parameters for each class.  */
 834     return tsk_insufficient_parms;
 835   else if (n_template_parm_scopes == n_class_scopes)
 836     /* We're processing a non-template declaration (even though it may
 837        be a member of a template class.)  For example:
 838
 839          template <class T> void S<T>::f(int);
 840
 841        The `class T' maches the `S<T>', leaving no template headers
 842        corresponding to the `f'.  */
 843     return tsk_none;
 844   else if (n_template_parm_scopes > n_class_scopes + 1)
 845     /* We've got too many template headers.  For example:
 846
 847          template <> template <class T> void f (T);
 848
 849        There need to be more enclosing classes.  */
 850     return tsk_excessive_parms;
 851   else
 852     /* This must be a template.  It's of the form:
 853
 854          template <class T> template <class U> void S<T>::f(U);
 855
 856        This is a specialization if the innermost level was a
 857        specialization; otherwise it's just a definition of the
 858        template.  */
 859     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 860 }
 861
 862 void
 863 set_class_shadows (shadows)
 864      tree shadows;
 865 {
 866   class_binding_level->class_shadowed = shadows;
 867 }
 868
 869 /* Enter a new binding level.
 870    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 871    not for that of tags.  */
 872
 873 void
 874 pushlevel (tag_transparent)
 875      int tag_transparent;
 876 {
 877   struct binding_level *newlevel;
 878
 879   if (cfun && !doing_semantic_analysis_p ())
 880     return;
 881
 882   /* Reuse or create a struct for this binding level.  */
 883 #if defined(DEBUG_CP_BINDING_LEVELS)
 884   if (0)
 885 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 886   if (free_binding_level)
 887 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 888     {
 889       newlevel = free_binding_level;
 890       free_binding_level = free_binding_level->level_chain;
 891     }
 892   else
 893     newlevel = make_binding_level ();
 894
 895   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 896   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 897   keep_next_level_flag = 0;
 898 }
 899
 900 /* Enter a new scope.  The KIND indicates what kind of scope is being
 901    created.  */
 902
 903 void
 904 begin_scope (sk)
 905      scope_kind sk;
 906 {
 907   pushlevel (0);
 908
 909   switch (sk)
 910     {
 911     case sk_template_spec:
 912       current_binding_level->template_spec_p = 1;
 913       /* Fall through.  */
 914
 915     case sk_template_parms:
 916       current_binding_level->template_parms_p = 1;
 917       break;
 918
 919     default:
 920       my_friendly_abort (20000309);
 921     }
 922 }
 923
 924 /* Exit the current scope.  */
 925
 926 void
 927 finish_scope ()
 928 {
 929   poplevel (0, 0, 0);
 930 }
 931
 932 void
 933 note_level_for_for ()
 934 {
 935   current_binding_level->is_for_scope = 1;
 936 }
 937
 938 /* For a binding between a name and an entity at a block scope,
 939    this is the `struct binding_level' for the block.  */
 940 #define BINDING_LEVEL(NODE) \
 941    (((struct tree_binding*)NODE)->scope.level)
 942
 943 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 944    level at which this declaration is being bound.  */
 945
 946 static void
 947 push_binding (id, decl, level)
 948      tree id;
 949      tree decl;
 950      struct binding_level* level;
 951 {
 952   tree binding;
 953
 954   binding = make_node (CPLUS_BINDING);
 955
 956   /* Now, fill in the binding information.  */
 957   BINDING_VALUE (binding) = decl;
 958   BINDING_TYPE (binding) = NULL_TREE;
 959   BINDING_LEVEL (binding) = level;
 960   INHERITED_VALUE_BINDING_P (binding) = 0;
 961   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 962   BINDING_HAS_LEVEL_P (binding) = 1;
 963
 964   /* And put it on the front of the list of bindings for ID.  */
 965   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 966   IDENTIFIER_BINDING (id) = binding;
 967 }
 968
 969 /* ID is already bound in the current scope.  But, DECL is an
 970    additional binding for ID in the same scope.  This is the `struct
 971    stat' hack whereby a non-typedef class-name or enum-name can be
 972    bound at the same level as some other kind of entity.  It's the
 973    responsibility of the caller to check that inserting this name is
 974    legal here.  Returns nonzero if the new binding was successful.  */
 975 static int
 976 add_binding (id, decl)
 977      tree id;
 978      tree decl;
 979 {
 980   tree binding = IDENTIFIER_BINDING (id);
 981   int ok = 1;
 982
 983   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 984     /* The new name is the type name.  */
 985     BINDING_TYPE (binding) = decl;
 986   else if (!BINDING_VALUE (binding))
 987     /* This situation arises when push_class_level_binding moves an
 988        inherited type-binding out of the way to make room for a new
 989        value binding.  */
 990     BINDING_VALUE (binding) = decl;
 991   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 992            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 993     {
 994       /* The old binding was a type name.  It was placed in
 995          BINDING_VALUE because it was thought, at the point it was
 996          declared, to be the only entity with such a name.  Move the
 997          type name into the type slot; it is now hidden by the new
 998          binding.  */
 999       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1000       BINDING_VALUE (binding) = decl;
1001       INHERITED_VALUE_BINDING_P (binding) = 0;
1002     }
1003   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1004            && TREE_CODE (decl) == TYPE_DECL
1005            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1006            && same_type_p (TREE_TYPE (decl),
1007                            TREE_TYPE (BINDING_VALUE (binding))))
1008     /* We have two typedef-names, both naming the same type to have
1009        the same name.  This is OK because of:
1010
1011          [dcl.typedef]
1012
1013          In a given scope, a typedef specifier can be used to redefine
1014          the name of any type declared in that scope to refer to the
1015          type to which it already refers.  */
1016     ok = 0;
1017   else
1018     {
1019       cp_error ("declaration of `%#D'", decl);
1020       cp_error_at ("conflicts with previous declaration `%#D'",
1021                    BINDING_VALUE (binding));
1022       ok = 0;
1023     }
1024
1025   return ok;
1026 }
1027
1028 /* Add DECL to the list of things declared in B.  */
1029
1030 static void
1031 add_decl_to_level (decl, b)
1032      tree decl;
1033      struct binding_level *b;
1034 {
1035   /* We build up the list in reverse order, and reverse it later if
1036      necessary.  */
1037   TREE_CHAIN (decl) = b->names;
1038   b->names = decl;
1039 }
1040
1041 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1042    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1043    doesn't really belong to this binding level, that it got here
1044    through a using-declaration.  */
1045
1046 void
1047 push_local_binding (id, decl, flags)
1048      tree id;
1049      tree decl;
1050      int flags;
1051 {
1052   struct binding_level *b;
1053
1054   /* Skip over any local classes.  This makes sense if we call
1055      push_local_binding with a friend decl of a local class.  */
1056   b = current_binding_level;
1057   while (b->parm_flag == 2)
1058     b = b->level_chain;
1059
1060   if (lookup_name_current_level (id))
1061     {
1062       /* Supplement the existing binding.  */
1063       if (!add_binding (id, decl))
1064         /* It didn't work.  Something else must be bound at this
1065            level.  Do not add DECL to the list of things to pop
1066            later.  */
1067         return;
1068     }
1069   else
1070     /* Create a new binding.  */
1071     push_binding (id, decl, b);
1072
1073   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1074     /* We must put the OVERLOAD into a TREE_LIST since the
1075        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1076        decls that got here through a using-declaration.  */
1077     decl = build_tree_list (NULL_TREE, decl);
1078
1079   /* And put DECL on the list of things declared by the current
1080      binding level.  */
1081   add_decl_to_level (decl, b);
1082 }
1083
1084 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1085    binding was successful.  */
1086
1087 int
1088 push_class_binding (id, decl)
1089      tree id;
1090      tree decl;
1091 {
1092   int result = 1;
1093   tree binding = IDENTIFIER_BINDING (id);
1094   tree context;
1095
1096   /* Note that we declared this value so that we can issue an error if
1097      this an illegal redeclaration of a name already used for some
1098      other purpose.  */
1099   note_name_declared_in_class (id, decl);
1100
1101   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1102     /* Supplement the existing binding.  */
1103     result = add_binding (id, decl);
1104   else
1105     /* Create a new binding.  */
1106     push_binding (id, decl, class_binding_level);
1107
1108   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1109      class-level declaration.  Note that we do not use DECL here
1110      because of the possibility of the `struct stat' hack; if DECL is
1111      a class-name or enum-name we might prefer a field-name, or some
1112      such.  */
1113   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1114
1115   /* If this is a binding from a base class, mark it as such.  */
1116   binding = IDENTIFIER_BINDING (id);
1117   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1118     {
1119       /* Any implicit typename must be from a base-class.  The
1120          context for an implicit typename declaration is always
1121          the derived class in which the lookup was done, so the checks
1122          based on the context of DECL below will not trigger.  */
1123       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1124         INHERITED_VALUE_BINDING_P (binding) = 1;
1125       else
1126         {
1127           if (TREE_CODE (decl) == OVERLOAD)
1128             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1129           else
1130             {
1131               my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd',
1132                                   0);
1133               context = CP_DECL_CONTEXT (decl);
1134             }
1135
1136           if (is_properly_derived_from (current_class_type, context))
1137             INHERITED_VALUE_BINDING_P (binding) = 1;
1138           else
1139             INHERITED_VALUE_BINDING_P (binding) = 0;
1140         }
1141     }
1142   else if (BINDING_VALUE (binding) == decl)
1143     /* We only encounter a TREE_LIST when push_class_decls detects an
1144        ambiguity.  Such an ambiguity can be overridden by a definition
1145        in this class.  */
1146     INHERITED_VALUE_BINDING_P (binding) = 1;
1147
1148   return result;
1149 }
1150
1151 /* Remove the binding for DECL which should be the innermost binding
1152    for ID.  */
1153
1154 static void
1155 pop_binding (id, decl)
1156      tree id;
1157      tree decl;
1158 {
1159   tree binding;
1160
1161   if (id == NULL_TREE)
1162     /* It's easiest to write the loops that call this function without
1163        checking whether or not the entities involved have names.  We
1164        get here for such an entity.  */
1165     return;
1166
1167   /* Get the innermost binding for ID.  */
1168   binding = IDENTIFIER_BINDING (id);
1169
1170   /* The name should be bound.  */
1171   my_friendly_assert (binding != NULL_TREE, 0);
1172
1173   /* The DECL will be either the ordinary binding or the type
1174      binding for this identifier.  Remove that binding.  */
1175   if (BINDING_VALUE (binding) == decl)
1176     BINDING_VALUE (binding) = NULL_TREE;
1177   else if (BINDING_TYPE (binding) == decl)
1178     BINDING_TYPE (binding) = NULL_TREE;
1179   else
1180     my_friendly_abort (0);
1181
1182   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1183     /* We're completely done with the innermost binding for this
1184        identifier.  Unhook it from the list of bindings.  */
1185     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1186 }
1187
1188 /* When a label goes out of scope, check to see if that label was used
1189    in a valid manner, and issue any appropriate warnings or errors.  */
1190
1191 static void
1192 pop_label (link)
1193      tree link;
1194 {
1195   tree label = TREE_VALUE (link);
1196
1197   if (!processing_template_decl && doing_semantic_analysis_p ())
1198     {
1199       if (DECL_INITIAL (label) == NULL_TREE)
1200         {
1201           cp_error_at ("label `%D' used but not defined", label);
1202           /* Avoid crashing later.  */
1203           define_label (input_filename, 1, DECL_NAME (label));
1204         }
1205       else if (warn_unused && !TREE_USED (label))
1206         cp_warning_at ("label `%D' defined but not used", label);
1207     }
1208
1209   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), TREE_PURPOSE (link));
1210 }
1211
1212 /* At the end of a function, all labels declared within the fucntion
1213    go out of scope.  BLOCK is the top-level block for the
1214    function.  */
1215
1216 static void
1217 pop_labels (block)
1218      tree block;
1219 {
1220   tree link;
1221
1222   /* Clear out the definitions of all label names, since their scopes
1223      end here.  */
1224   for (link = named_labels; link; link = TREE_CHAIN (link))
1225     {
1226       pop_label (link);
1227       /* Put the labels into the "variables" of the top-level block,
1228          so debugger can see them.  */
1229       TREE_CHAIN (TREE_VALUE (link)) = BLOCK_VARS (block);
1230       BLOCK_VARS (block) = TREE_VALUE (link);
1231     }
1232
1233   named_labels = NULL_TREE;
1234 }
1235
1236 /* Exit a binding level.
1237    Pop the level off, and restore the state of the identifier-decl mappings
1238    that were in effect when this level was entered.
1239
1240    If KEEP == 1, this level had explicit declarations, so
1241    and create a "block" (a BLOCK node) for the level
1242    to record its declarations and subblocks for symbol table output.
1243
1244    If FUNCTIONBODY is nonzero, this level is the body of a function,
1245    so create a block as if KEEP were set and also clear out all
1246    label names.
1247
1248    If REVERSE is nonzero, reverse the order of decls before putting
1249    them into the BLOCK.  */
1250
1251 tree
1252 poplevel (keep, reverse, functionbody)
1253      int keep;
1254      int reverse;
1255      int functionbody;
1256 {
1257   register tree link;
1258   /* The chain of decls was accumulated in reverse order.
1259      Put it into forward order, just for cleanliness.  */
1260   tree decls;
1261   int tmp = functionbody;
1262   int real_functionbody;
1263   tree tags;
1264   tree subblocks;
1265   tree block = NULL_TREE;
1266   tree decl;
1267   int block_previously_created;
1268   int leaving_for_scope;
1269
1270   if (cfun && !doing_semantic_analysis_p ())
1271     return NULL_TREE;
1272
1273   my_friendly_assert (current_binding_level->parm_flag != 2,
1274                       19990916);
1275
1276   real_functionbody = (current_binding_level->keep == 2
1277                        ? ((functionbody = 0), tmp) : functionbody);
1278   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1279   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1280
1281   my_friendly_assert (!current_binding_level->class_shadowed,
1282                       19990414);
1283
1284   /* We used to use KEEP == 2 to indicate that the new block should go
1285      at the beginning of the list of blocks at this binding level,
1286      rather than the end.  This hack is no longer used.  */
1287   my_friendly_assert (keep == 0 || keep == 1, 0);
1288
1289   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1290                       (HOST_WIDE_INT) current_binding_level->level_chain,
1291                       current_binding_level->parm_flag,
1292                       current_binding_level->keep);
1293
1294   if (current_binding_level->keep == 1)
1295     keep = 1;
1296
1297   /* Get the decls in the order they were written.
1298      Usually current_binding_level->names is in reverse order.
1299      But parameter decls were previously put in forward order.  */
1300
1301   if (reverse)
1302     current_binding_level->names
1303       = decls = nreverse (current_binding_level->names);
1304   else
1305     decls = current_binding_level->names;
1306
1307   /* Output any nested inline functions within this block
1308      if they weren't already output.  */
1309   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1310     if (TREE_CODE (decl) == FUNCTION_DECL
1311         && ! TREE_ASM_WRITTEN (decl)
1312         && DECL_INITIAL (decl) != NULL_TREE
1313         && TREE_ADDRESSABLE (decl)
1314         && decl_function_context (decl) == current_function_decl)
1315       {
1316         /* If this decl was copied from a file-scope decl
1317            on account of a block-scope extern decl,
1318            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1319         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1320           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1321         else
1322           {
1323             push_function_context ();
1324             output_inline_function (decl);
1325             pop_function_context ();
1326           }
1327       }
1328
1329   /* When not in function-at-a-time mode, expand_end_bindings will
1330      warn about unused variables.  But, in function-at-a-time mode
1331      expand_end_bindings is not passed the list of variables in the
1332      current scope, and therefore no warning is emitted.  So, we
1333      explicitly warn here.  */
1334   if (!processing_template_decl)
1335     warn_about_unused_variables (getdecls ());
1336
1337   /* If there were any declarations or structure tags in that level,
1338      or if this level is a function body,
1339      create a BLOCK to record them for the life of this function.  */
1340   block = NULL_TREE;
1341   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1342   if (block_previously_created)
1343     block = current_binding_level->this_block;
1344   else if (keep == 1 || functionbody)
1345     block = make_node (BLOCK);
1346   if (block != NULL_TREE)
1347     {
1348       if (block_previously_created)
1349         {
1350           if (decls || tags || subblocks)
1351             {
1352               if (BLOCK_VARS (block))
1353                 warning ("internal compiler error: debugging info corrupted");
1354
1355               BLOCK_VARS (block) = decls;
1356
1357               /* We can have previous subblocks and new subblocks when
1358                  doing fixup_gotos with complex cleanups.  We chain the new
1359                  subblocks onto the end of any pre-existing subblocks.  */
1360               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1361                                                  subblocks);
1362             }
1363         }
1364       else
1365         {
1366           BLOCK_VARS (block) = decls;
1367           BLOCK_SUBBLOCKS (block) = subblocks;
1368         }
1369     }
1370
1371   /* In each subblock, record that this is its superior.  */
1372   if (keep >= 0)
1373     for (link = subblocks; link; link = TREE_CHAIN (link))
1374       BLOCK_SUPERCONTEXT (link) = block;
1375
1376   /* We still support the old for-scope rules, whereby the variables
1377      in a for-init statement were in scope after the for-statement
1378      ended.  We only use the new rules in flag_new_for_scope is
1379      nonzero.  */
1380   leaving_for_scope
1381     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1382
1383   /* Remove declarations for all the DECLs in this level.  */
1384   for (link = decls; link; link = TREE_CHAIN (link))
1385     {
1386       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1387         {
1388           tree outer_binding
1389             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1390           tree ns_binding;
1391
1392           if (!outer_binding)
1393             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1394           else
1395             ns_binding = NULL_TREE;
1396
1397           if (outer_binding
1398               && (BINDING_LEVEL (outer_binding)
1399                   == current_binding_level->level_chain))
1400             /* We have something like:
1401
1402                  int i;
1403                  for (int i; ;);
1404
1405                and we are leaving the `for' scope.  There's no reason to
1406                keep the binding of the inner `i' in this case.  */
1407             pop_binding (DECL_NAME (link), link);
1408           else if ((outer_binding
1409                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1410                         == TYPE_DECL))
1411                    || (ns_binding
1412                        && TREE_CODE (ns_binding) == TYPE_DECL))
1413             /* Here, we have something like:
1414
1415                  typedef int I;
1416
1417                  void f () {
1418                    for (int I; ;);
1419                  }
1420
1421                We must pop the for-scope binding so we know what's a
1422                type and what isn't.  */
1423             pop_binding (DECL_NAME (link), link);
1424           else
1425             {
1426               /* Mark this VAR_DECL as dead so that we can tell we left it
1427                  there only for backward compatibility.  */
1428               DECL_DEAD_FOR_LOCAL (link) = 1;
1429
1430               /* Keep track of what should of have happenned when we
1431                  popped the binding.  */
1432               if (outer_binding && BINDING_VALUE (outer_binding))
1433                 DECL_SHADOWED_FOR_VAR (link)
1434                   = BINDING_VALUE (outer_binding);
1435
1436               /* Add it to the list of dead variables in the next
1437                  outermost binding to that we can remove these when we
1438                  leave that binding.  */
1439               current_binding_level->level_chain->dead_vars_from_for
1440                 = tree_cons (NULL_TREE, link,
1441                              current_binding_level->level_chain->
1442                              dead_vars_from_for);
1443
1444               /* Although we don't pop the CPLUS_BINDING, we do clear
1445                  its BINDING_LEVEL since the level is going away now.  */
1446               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1447                 = 0;
1448             }
1449         }
1450       else
1451         {
1452           /* Remove the binding.  */
1453           decl = link;
1454           if (TREE_CODE (decl) == TREE_LIST)
1455             decl = TREE_VALUE (decl);
1456           if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
1457             pop_binding (DECL_NAME (decl), decl);
1458           else if (TREE_CODE (decl) == OVERLOAD)
1459             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1460           else
1461             my_friendly_abort (0);
1462         }
1463     }
1464
1465   /* Remove declarations for any `for' variables from inner scopes
1466      that we kept around.  */
1467   for (link = current_binding_level->dead_vars_from_for;
1468        link; link = TREE_CHAIN (link))
1469     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1470
1471   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1472   for (link = current_binding_level->type_shadowed;
1473        link; link = TREE_CHAIN (link))
1474     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1475
1476   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1477   for (link = current_binding_level->shadowed_labels;
1478        link;
1479        link = TREE_CHAIN (link))
1480     pop_label (link);
1481
1482   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1483      list if a `using' declaration put them there.  The debugging
1484      back-ends won't understand OVERLOAD, so we remove them here.
1485      Because the BLOCK_VARS are (temporarily) shared with
1486      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1487      popped all the bindings.  */
1488   if (block)
1489     {
1490       tree* d;
1491
1492       for (d = &BLOCK_VARS (block); *d; )
1493         {
1494           if (TREE_CODE (*d) == TREE_LIST)
1495             *d = TREE_CHAIN (*d);
1496           else
1497             d = &TREE_CHAIN (*d);
1498         }
1499     }
1500
1501   /* If the level being exited is the top level of a function,
1502      check over all the labels.  */
1503   if (functionbody)
1504     {
1505       /* Since this is the top level block of a function, the vars are
1506          the function's parameters.  Don't leave them in the BLOCK
1507          because they are found in the FUNCTION_DECL instead.  */
1508       BLOCK_VARS (block) = 0;
1509       pop_labels (block);
1510     }
1511
1512   /* Any uses of undefined labels now operate under constraints
1513      of next binding contour.  */
1514   if (cfun)
1515     {
1516       struct binding_level *level_chain;
1517       level_chain = current_binding_level->level_chain;
1518       if (level_chain)
1519         {
1520           struct named_label_list *labels;
1521           for (labels = named_label_uses; labels; labels = labels->next)
1522             if (labels->binding_level == current_binding_level)
1523               {
1524                 labels->binding_level = level_chain;
1525                 labels->names_in_scope = level_chain->names;
1526               }
1527         }
1528     }
1529
1530   tmp = current_binding_level->keep;
1531
1532   pop_binding_level ();
1533   if (functionbody)
1534     DECL_INITIAL (current_function_decl) = block;
1535   else if (block)
1536     {
1537       if (!block_previously_created)
1538         current_binding_level->blocks
1539           = chainon (current_binding_level->blocks, block);
1540     }
1541   /* If we did not make a block for the level just exited,
1542      any blocks made for inner levels
1543      (since they cannot be recorded as subblocks in that level)
1544      must be carried forward so they will later become subblocks
1545      of something else.  */
1546   else if (subblocks)
1547     current_binding_level->blocks
1548       = chainon (current_binding_level->blocks, subblocks);
1549
1550   /* Each and every BLOCK node created here in `poplevel' is important
1551      (e.g. for proper debugging information) so if we created one
1552      earlier, mark it as "used".  */
1553   if (block)
1554     TREE_USED (block) = 1;
1555
1556   /* Take care of compiler's internal binding structures.  */
1557   if (tmp == 2)
1558     {
1559       tree scope_stmts;
1560
1561       scope_stmts
1562         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1563       if (block)
1564         {
1565           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1566           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1567         }
1568
1569       block = poplevel (keep, reverse, functionbody);
1570     }
1571
1572   return block;
1573 }
1574
1575 /* Delete the node BLOCK from the current binding level.
1576    This is used for the block inside a stmt expr ({...})
1577    so that the block can be reinserted where appropriate.  */
1578
1579 void
1580 delete_block (block)
1581      tree block;
1582 {
1583   tree t;
1584   if (current_binding_level->blocks == block)
1585     current_binding_level->blocks = TREE_CHAIN (block);
1586   for (t = current_binding_level->blocks; t;)
1587     {
1588       if (TREE_CHAIN (t) == block)
1589         TREE_CHAIN (t) = TREE_CHAIN (block);
1590       else
1591         t = TREE_CHAIN (t);
1592     }
1593   TREE_CHAIN (block) = NULL_TREE;
1594   /* Clear TREE_USED which is always set by poplevel.
1595      The flag is set again if insert_block is called.  */
1596   TREE_USED (block) = 0;
1597 }
1598
1599 /* Insert BLOCK at the end of the list of subblocks of the
1600    current binding level.  This is used when a BIND_EXPR is expanded,
1601    to handle the BLOCK node inside the BIND_EXPR.  */
1602
1603 void
1604 insert_block (block)
1605      tree block;
1606 {
1607   TREE_USED (block) = 1;
1608   current_binding_level->blocks
1609     = chainon (current_binding_level->blocks, block);
1610 }
1611
1612 /* Set the BLOCK node for the innermost scope
1613    (the one we are currently in).  */
1614
1615 void
1616 set_block (block)
1617     register tree block;
1618 {
1619   current_binding_level->this_block = block;
1620 }
1621
1622 /* Do a pushlevel for class declarations.  */
1623
1624 void
1625 pushlevel_class ()
1626 {
1627   register struct binding_level *newlevel;
1628
1629   /* Reuse or create a struct for this binding level.  */
1630 #if defined(DEBUG_CP_BINDING_LEVELS)
1631   if (0)
1632 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1633   if (free_binding_level)
1634 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1635     {
1636       newlevel = free_binding_level;
1637       free_binding_level = free_binding_level->level_chain;
1638     }
1639   else
1640     newlevel = make_binding_level ();
1641
1642 #if defined(DEBUG_CP_BINDING_LEVELS)
1643   is_class_level = 1;
1644 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1645
1646   push_binding_level (newlevel, 0, 0);
1647
1648   class_binding_level = current_binding_level;
1649   class_binding_level->parm_flag = 2;
1650   class_binding_level->this_class = current_class_type;
1651 }
1652
1653 /* ...and a poplevel for class declarations.  */
1654
1655 void
1656 poplevel_class ()
1657 {
1658   register struct binding_level *level = class_binding_level;
1659   tree shadowed;
1660
1661   my_friendly_assert (level != 0, 354);
1662
1663   /* If we're leaving a toplevel class, don't bother to do the setting
1664      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1665      shouldn't even be used when current_class_type isn't set, and second,
1666      if we don't touch it here, we're able to use the cache effect if the
1667      next time we're entering a class scope, it is the same class.  */
1668   if (current_class_depth != 1)
1669     {
1670       struct binding_level* b;
1671
1672       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1673       for (shadowed = level->class_shadowed;
1674            shadowed;
1675            shadowed = TREE_CHAIN (shadowed))
1676         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1677
1678       /* Find the next enclosing class, and recreate
1679          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1680       b = level->level_chain;
1681       while (b && b->parm_flag != 2)
1682         b = b->level_chain;
1683
1684       if (b)
1685         for (shadowed = b->class_shadowed;
1686              shadowed;
1687              shadowed = TREE_CHAIN (shadowed))
1688           {
1689             tree t;
1690
1691             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1692             while (t && BINDING_LEVEL (t) != b)
1693               t = TREE_CHAIN (t);
1694
1695             if (t)
1696               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1697                 = BINDING_VALUE (t);
1698           }
1699     }
1700   else
1701     /* Remember to save what IDENTIFIER's were bound in this scope so we
1702        can recover from cache misses.  */
1703     {
1704       previous_class_type = current_class_type;
1705       previous_class_values = class_binding_level->class_shadowed;
1706     }
1707   for (shadowed = level->type_shadowed;
1708        shadowed;
1709        shadowed = TREE_CHAIN (shadowed))
1710     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1711
1712   /* Remove the bindings for all of the class-level declarations.  */
1713   for (shadowed = level->class_shadowed;
1714        shadowed;
1715        shadowed = TREE_CHAIN (shadowed))
1716     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1717
1718   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1719                       (HOST_WIDE_INT) class_binding_level->level_chain,
1720                       class_binding_level->parm_flag,
1721                       class_binding_level->keep);
1722
1723   /* Now, pop out of the binding level which we created up in the
1724      `pushlevel_class' routine.  */
1725 #if defined(DEBUG_CP_BINDING_LEVELS)
1726   is_class_level = 1;
1727 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1728
1729   pop_binding_level ();
1730 }
1731
1732 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1733    for any names in enclosing classes.  */
1734
1735 void
1736 clear_identifier_class_values ()
1737 {
1738   tree t;
1739
1740   if (!class_binding_level)
1741     return;
1742
1743   for (t = class_binding_level->class_shadowed;
1744        t;
1745        t = TREE_CHAIN (t))
1746     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1747 }
1748
1749 /* Returns non-zero if T is a virtual function table.  */
1750
1751 int
1752 vtable_decl_p (t, data)
1753      tree t;
1754      void *data ATTRIBUTE_UNUSED;
1755 {
1756   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1757 }
1758
1759 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1760    functions.  */
1761
1762 int
1763 vtype_decl_p (t, data)
1764      tree t;
1765      void *data ATTRIBUTE_UNUSED;
1766 {
1767   return (TREE_CODE (t) == TYPE_DECL
1768           && TREE_TYPE (t) != error_mark_node
1769           && TYPE_LANG_SPECIFIC (TREE_TYPE (t))
1770           && CLASSTYPE_VSIZE (TREE_TYPE (t)));
1771 }
1772
1773 /* Return the declarations that are members of the namespace NS.  */
1774
1775 tree
1776 cp_namespace_decls (ns)
1777      tree ns;
1778 {
1779   return NAMESPACE_LEVEL (ns)->names;
1780 }
1781
1782 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1783    itself, calling F for each.  The DATA is passed to F as well.  */
1784
1785 static int
1786 walk_namespaces_r (namespace, f, data)
1787      tree namespace;
1788      walk_namespaces_fn f;
1789      void *data;
1790 {
1791   tree current;
1792   int result = 0;
1793
1794   result |= (*f) (namespace, data);
1795
1796   for (current = cp_namespace_decls (namespace);
1797        current;
1798        current = TREE_CHAIN (current))
1799     {
1800       if (TREE_CODE (current) != NAMESPACE_DECL
1801           || DECL_NAMESPACE_ALIAS (current))
1802         continue;
1803       if (!DECL_LANG_SPECIFIC (current))
1804         {
1805           /* Hmm. std. */
1806           my_friendly_assert (current == std_node, 393);
1807           continue;
1808         }
1809
1810       /* We found a namespace.  */
1811       result |= walk_namespaces_r (current, f, data);
1812     }
1813
1814   return result;
1815 }
1816
1817 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1818    F as well.  */
1819
1820 int
1821 walk_namespaces (f, data)
1822      walk_namespaces_fn f;
1823      void *data;
1824 {
1825   return walk_namespaces_r (global_namespace, f, data);
1826 }
1827
1828 struct walk_globals_data {
1829   walk_globals_pred p;
1830   walk_globals_fn f;
1831   void *data;
1832 };
1833
1834 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1835    for which P returns non-zero, call F with its address.  If any call
1836    to F returns a non-zero value, return a non-zero value.  */
1837
1838 static int
1839 walk_globals_r (namespace, data)
1840      tree namespace;
1841      void *data;
1842 {
1843   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1844   walk_globals_pred p = wgd->p;
1845   walk_globals_fn f = wgd->f;
1846   void *d = wgd->data;
1847   tree *t;
1848   int result = 0;
1849
1850   t = &NAMESPACE_LEVEL (namespace)->names;
1851
1852   while (*t)
1853     {
1854       tree glbl = *t;
1855
1856       if ((*p) (glbl, d))
1857         result |= (*f) (t, d);
1858
1859       /* If F changed *T, then *T still points at the next item to
1860          examine.  */
1861       if (*t == glbl)
1862         t = &TREE_CHAIN (*t);
1863     }
1864
1865   return result;
1866 }
1867
1868 /* Walk the global declarations.  Whenever one is found for which P
1869    returns non-zero, call F with its address.  If any call to F
1870    returns a non-zero value, return a non-zero value.  */
1871
1872 int
1873 walk_globals (p, f, data)
1874      walk_globals_pred p;
1875      walk_globals_fn f;
1876      void *data;
1877 {
1878   struct walk_globals_data wgd;
1879   wgd.p = p;
1880   wgd.f = f;
1881   wgd.data = data;
1882
1883   return walk_namespaces (walk_globals_r, &wgd);
1884 }
1885
1886 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1887    DATA is non-NULL, this is the last time we will call
1888    wrapup_global_declarations for this NAMESPACE.  */
1889
1890 int
1891 wrapup_globals_for_namespace (namespace, data)
1892      tree namespace;
1893      void *data;
1894 {
1895   tree globals = cp_namespace_decls (namespace);
1896   int len = list_length (globals);
1897   tree *vec = (tree *) alloca (sizeof (tree) * len);
1898   int i;
1899   int result;
1900   tree decl;
1901   int last_time = (data != 0);
1902
1903   if (last_time && namespace == global_namespace)
1904     /* Let compile_file handle the global namespace.  */
1905     return 0;
1906
1907   /* Process the decls in reverse order--earliest first.
1908      Put them into VEC from back to front, then take out from front.  */
1909
1910   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1911     {
1912       /* Pretend we've output an unused static variable.  This ensures
1913          that the toplevel __FUNCTION__ etc won't be emitted, unless
1914          needed. */
1915       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1916           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1917         {
1918           TREE_ASM_WRITTEN (decl) = 1;
1919           DECL_IGNORED_P (decl) = 1;
1920         }
1921       vec[len - i - 1] = decl;
1922     }
1923
1924   if (last_time)
1925     {
1926       check_global_declarations (vec, len);
1927       return 0;
1928     }
1929
1930   /* Temporarily mark vtables as external.  That prevents
1931      wrapup_global_declarations from writing them out; we must process
1932      them ourselves in finish_vtable_vardecl.  */
1933   for (i = 0; i < len; ++i)
1934     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1935       {
1936         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1937         DECL_EXTERNAL (vec[i]) = 1;
1938       }
1939
1940   /* Write out any globals that need to be output.  */
1941   result = wrapup_global_declarations (vec, len);
1942
1943   /* Undo the hack to DECL_EXTERNAL above.  */
1944   for (i = 0; i < len; ++i)
1945     if (vtable_decl_p (vec[i], /*data=*/0)
1946         && DECL_NOT_REALLY_EXTERN (vec[i]))
1947       {
1948         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1949         DECL_EXTERNAL (vec[i]) = 0;
1950       }
1951
1952   return result;
1953 }
1954
1955 \f
1956 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1957
1958 static void
1959 mark_binding_level (arg)
1960      void *arg;
1961 {
1962   struct binding_level *lvl = *(struct binding_level **)arg;
1963
1964   while (lvl)
1965     {
1966       ggc_mark_tree (lvl->names);
1967       ggc_mark_tree (lvl->tags);
1968       ggc_mark_tree (lvl->usings);
1969       ggc_mark_tree (lvl->using_directives);
1970       ggc_mark_tree (lvl->class_shadowed);
1971       ggc_mark_tree (lvl->type_shadowed);
1972       ggc_mark_tree (lvl->shadowed_labels);
1973       ggc_mark_tree (lvl->blocks);
1974       ggc_mark_tree (lvl->this_block);
1975       ggc_mark_tree (lvl->this_class);
1976       ggc_mark_tree (lvl->incomplete);
1977       ggc_mark_tree (lvl->dead_vars_from_for);
1978
1979       lvl = lvl->level_chain;
1980     }
1981 }
1982 \f
1983 /* For debugging.  */
1984 static int no_print_functions = 0;
1985 static int no_print_builtins = 0;
1986
1987 void
1988 print_binding_level (lvl)
1989      struct binding_level *lvl;
1990 {
1991   tree t;
1992   int i = 0, len;
1993   fprintf (stderr, " blocks=");
1994   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1995   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1996            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1997   if (lvl->tag_transparent)
1998     fprintf (stderr, " tag-transparent");
1999   if (lvl->more_cleanups_ok)
2000     fprintf (stderr, " more-cleanups-ok");
2001   if (lvl->have_cleanups)
2002     fprintf (stderr, " have-cleanups");
2003   fprintf (stderr, "\n");
2004   if (lvl->names)
2005     {
2006       fprintf (stderr, " names:\t");
2007       /* We can probably fit 3 names to a line?  */
2008       for (t = lvl->names; t; t = TREE_CHAIN (t))
2009         {
2010           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2011             continue;
2012           if (no_print_builtins
2013               && (TREE_CODE (t) == TYPE_DECL)
2014               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2015             continue;
2016
2017           /* Function decls tend to have longer names.  */
2018           if (TREE_CODE (t) == FUNCTION_DECL)
2019             len = 3;
2020           else
2021             len = 2;
2022           i += len;
2023           if (i > 6)
2024             {
2025               fprintf (stderr, "\n\t");
2026               i = len;
2027             }
2028           print_node_brief (stderr, "", t, 0);
2029           if (t == error_mark_node)
2030             break;
2031         }
2032       if (i)
2033         fprintf (stderr, "\n");
2034     }
2035   if (lvl->tags)
2036     {
2037       fprintf (stderr, " tags:\t");
2038       i = 0;
2039       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2040         {
2041           if (TREE_PURPOSE (t) == NULL_TREE)
2042             len = 3;
2043           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2044             len = 2;
2045           else
2046             len = 4;
2047           i += len;
2048           if (i > 5)
2049             {
2050               fprintf (stderr, "\n\t");
2051               i = len;
2052             }
2053           if (TREE_PURPOSE (t) == NULL_TREE)
2054             {
2055               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2056               fprintf (stderr, ">");
2057             }
2058           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2059             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2060           else
2061             {
2062               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2063               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2064               fprintf (stderr, ">");
2065             }
2066         }
2067       if (i)
2068         fprintf (stderr, "\n");
2069     }
2070   if (lvl->class_shadowed)
2071     {
2072       fprintf (stderr, " class-shadowed:");
2073       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2074         {
2075           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2076         }
2077       fprintf (stderr, "\n");
2078     }
2079   if (lvl->type_shadowed)
2080     {
2081       fprintf (stderr, " type-shadowed:");
2082       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2083         {
2084           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2085         }
2086       fprintf (stderr, "\n");
2087     }
2088 }
2089
2090 void
2091 print_other_binding_stack (stack)
2092      struct binding_level *stack;
2093 {
2094   struct binding_level *level;
2095   for (level = stack; level != global_binding_level; level = level->level_chain)
2096     {
2097       fprintf (stderr, "binding level ");
2098       fprintf (stderr, HOST_PTR_PRINTF, level);
2099       fprintf (stderr, "\n");
2100       print_binding_level (level);
2101     }
2102 }
2103
2104 void
2105 print_binding_stack ()
2106 {
2107   struct binding_level *b;
2108   fprintf (stderr, "current_binding_level=");
2109   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2110   fprintf (stderr, "\nclass_binding_level=");
2111   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2112   fprintf (stderr, "\nglobal_binding_level=");
2113   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2114   fprintf (stderr, "\n");
2115   if (class_binding_level)
2116     {
2117       for (b = class_binding_level; b; b = b->level_chain)
2118         if (b == current_binding_level)
2119           break;
2120       if (b)
2121         b = class_binding_level;
2122       else
2123         b = current_binding_level;
2124     }
2125   else
2126     b = current_binding_level;
2127   print_other_binding_stack (b);
2128   fprintf (stderr, "global:\n");
2129   print_binding_level (global_binding_level);
2130 }
2131
2132 /* Namespace binding access routines: The namespace_bindings field of
2133    the identifier is polymorphic, with three possible values:
2134    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2135    indicating the BINDING_VALUE of global_namespace. */
2136
2137 /* Check whether the a binding for the name to scope is known.
2138    Assumes that the bindings of the name are already a list
2139    of bindings. Returns the binding found, or NULL_TREE. */
2140
2141 static tree
2142 find_binding (name, scope)
2143      tree name;
2144      tree scope;
2145 {
2146   tree iter, prev = NULL_TREE;
2147
2148   scope = ORIGINAL_NAMESPACE (scope);
2149
2150   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2151        iter = TREE_CHAIN (iter))
2152     {
2153       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2154       if (BINDING_SCOPE (iter) == scope)
2155         {
2156           /* Move binding found to the front of the list, so
2157              subsequent lookups will find it faster. */
2158           if (prev)
2159             {
2160               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2161               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2162               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2163             }
2164           return iter;
2165         }
2166       prev = iter;
2167     }
2168   return NULL_TREE;
2169 }
2170
2171 /* Always returns a binding for name in scope. If the
2172    namespace_bindings is not a list, convert it to one first.
2173    If no binding is found, make a new one. */
2174
2175 tree
2176 binding_for_name (name, scope)
2177      tree name;
2178      tree scope;
2179 {
2180   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2181   tree result;
2182
2183   scope = ORIGINAL_NAMESPACE (scope);
2184
2185   if (b && TREE_CODE (b) != CPLUS_BINDING)
2186     {
2187       /* Get rid of optimization for global scope. */
2188       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2189       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2190       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2191     }
2192   if (b && (result = find_binding (name, scope)))
2193     return result;
2194   /* Not found, make a new one. */
2195   result = make_node (CPLUS_BINDING);
2196   TREE_CHAIN (result) = b;
2197   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2198   BINDING_SCOPE (result) = scope;
2199   BINDING_TYPE (result) = NULL_TREE;
2200   BINDING_VALUE (result) = NULL_TREE;
2201   return result;
2202 }
2203
2204 /* Return the binding value for name in scope, considering that
2205    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2206
2207 tree
2208 namespace_binding (name, scope)
2209      tree name;
2210      tree scope;
2211 {
2212   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2213   if (b == NULL_TREE)
2214     return NULL_TREE;
2215   if (scope == NULL_TREE)
2216     scope = global_namespace;
2217   if (TREE_CODE (b) != CPLUS_BINDING)
2218     return (scope == global_namespace) ? b : NULL_TREE;
2219   name = find_binding (name,scope);
2220   if (name == NULL_TREE)
2221     return name;
2222   return BINDING_VALUE (name);
2223 }
2224
2225 /* Set the binding value for name in scope. If modifying the binding
2226    of global_namespace is attempted, try to optimize it. */
2227
2228 void
2229 set_namespace_binding (name, scope, val)
2230      tree name;
2231      tree scope;
2232      tree val;
2233 {
2234   tree b;
2235
2236   if (scope == NULL_TREE)
2237     scope = global_namespace;
2238
2239   if (scope == global_namespace)
2240     {
2241       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2242       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2243         {
2244           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2245           return;
2246         }
2247     }
2248   b = binding_for_name (name, scope);
2249   BINDING_VALUE (b) = val;
2250 }
2251
2252 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2253    select a name that is unique to this compilation unit.  */
2254
2255 void
2256 push_namespace (name)
2257      tree name;
2258 {
2259   tree d = NULL_TREE;
2260   int need_new = 1;
2261   int implicit_use = 0;
2262   int global = 0;
2263   if (!global_namespace)
2264     {
2265       /* This must be ::. */
2266       my_friendly_assert (name == get_identifier ("::"), 377);
2267       global = 1;
2268     }
2269   else if (!name)
2270     {
2271       /* The name of anonymous namespace is unique for the translation
2272          unit.  */
2273       if (!anonymous_namespace_name)
2274         anonymous_namespace_name = get_file_function_name ('N');
2275       name = anonymous_namespace_name;
2276       d = IDENTIFIER_NAMESPACE_VALUE (name);
2277       if (d)
2278         /* Reopening anonymous namespace.  */
2279         need_new = 0;
2280       implicit_use = 1;
2281     }
2282   else if (current_namespace == global_namespace
2283            && name == DECL_NAME (std_node))
2284     {
2285       in_std++;
2286       return;
2287     }
2288   else
2289     {
2290       /* Check whether this is an extended namespace definition. */
2291       d = IDENTIFIER_NAMESPACE_VALUE (name);
2292       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2293         {
2294           need_new = 0;
2295           if (DECL_NAMESPACE_ALIAS (d))
2296             {
2297               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2298                         d, DECL_NAMESPACE_ALIAS (d));
2299               d = DECL_NAMESPACE_ALIAS (d);
2300             }
2301         }
2302     }
2303
2304   if (need_new)
2305     {
2306       /* Make a new namespace, binding the name to it. */
2307       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2308       /* The global namespace is not pushed, and the global binding
2309          level is set elsewhere.  */
2310       if (!global)
2311         {
2312           d = pushdecl (d);
2313           pushlevel (0);
2314           declare_namespace_level ();
2315           NAMESPACE_LEVEL (d) = current_binding_level;
2316         }
2317     }
2318   else
2319     resume_binding_level (NAMESPACE_LEVEL (d));
2320
2321   if (implicit_use)
2322     do_using_directive (d);
2323   /* Enter the name space. */
2324   current_namespace = d;
2325 }
2326
2327 /* Pop from the scope of the current namespace.  */
2328
2329 void
2330 pop_namespace ()
2331 {
2332   if (current_namespace == global_namespace)
2333     {
2334       my_friendly_assert (in_std>0, 980421);
2335       in_std--;
2336       return;
2337     }
2338   current_namespace = CP_DECL_CONTEXT (current_namespace);
2339   /* The binding level is not popped, as it might be re-opened later.  */
2340   suspend_binding_level ();
2341 }
2342
2343 /* Push into the scope of the namespace NS, even if it is deeply
2344    nested within another namespace.  */
2345
2346 void
2347 push_nested_namespace (ns)
2348      tree ns;
2349 {
2350   if (ns == global_namespace)
2351     push_to_top_level ();
2352   else
2353     {
2354       push_nested_namespace (CP_DECL_CONTEXT (ns));
2355       push_namespace (DECL_NAME (ns));
2356     }
2357 }
2358
2359 /* Pop back from the scope of the namespace NS, which was previously
2360    entered with push_nested_namespace.  */
2361
2362 void
2363 pop_nested_namespace (ns)
2364      tree ns;
2365 {
2366   while (ns != global_namespace)
2367     {
2368       pop_namespace ();
2369       ns = CP_DECL_CONTEXT (ns);
2370     }
2371
2372   pop_from_top_level ();
2373 }
2374
2375 \f
2376 /* Subroutines for reverting temporarily to top-level for instantiation
2377    of templates and such.  We actually need to clear out the class- and
2378    local-value slots of all identifiers, so that only the global values
2379    are at all visible.  Simply setting current_binding_level to the global
2380    scope isn't enough, because more binding levels may be pushed.  */
2381 struct saved_scope *scope_chain;
2382
2383 /* Mark ST for GC.  */
2384
2385 static void
2386 mark_stmt_tree (st)
2387      struct stmt_tree *st;
2388 {
2389   ggc_mark_tree (st->x_last_stmt);
2390   ggc_mark_tree (st->x_last_expr_type);
2391 }
2392
2393 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2394
2395 static void
2396 mark_saved_scope (arg)
2397      void *arg;
2398 {
2399   struct saved_scope *t = *(struct saved_scope **)arg;
2400   while (t)
2401     {
2402       mark_binding_level (&t->class_bindings);
2403       ggc_mark_tree (t->old_bindings);
2404       ggc_mark_tree (t->old_namespace);
2405       ggc_mark_tree (t->class_name);
2406       ggc_mark_tree (t->class_type);
2407       ggc_mark_tree (t->access_specifier);
2408       ggc_mark_tree (t->function_decl);
2409       if (t->lang_base)
2410         ggc_mark_tree_varray (t->lang_base);
2411       ggc_mark_tree (t->lang_name);
2412       ggc_mark_tree (t->x_function_parms);
2413       ggc_mark_tree (t->template_parms);
2414       ggc_mark_tree (t->x_previous_class_type);
2415       ggc_mark_tree (t->x_previous_class_values);
2416       ggc_mark_tree (t->x_saved_tree);
2417       ggc_mark_tree (t->incomplete);
2418       ggc_mark_tree (t->lookups);
2419
2420       mark_stmt_tree (&t->x_stmt_tree);
2421       mark_binding_level (&t->bindings);
2422       t = t->prev;
2423     }
2424 }
2425
2426 static tree
2427 store_bindings (names, old_bindings)
2428      tree names, old_bindings;
2429 {
2430   tree t;
2431   for (t = names; t; t = TREE_CHAIN (t))
2432     {
2433       tree binding, t1, id;
2434
2435       if (TREE_CODE (t) == TREE_LIST)
2436         id = TREE_PURPOSE (t);
2437       else
2438         id = DECL_NAME (t);
2439
2440       if (!id
2441           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2442              we have no IDENTIFIER_BINDING if we have left the class
2443              scope, but cached the class-level declarations.  */
2444           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2445         continue;
2446
2447       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2448         if (TREE_VEC_ELT (t1, 0) == id)
2449           goto skip_it;
2450
2451       binding = make_tree_vec (4);
2452
2453       if (id)
2454         {
2455           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2456           TREE_VEC_ELT (binding, 0) = id;
2457           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2458           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2459           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2460           IDENTIFIER_BINDING (id) = NULL_TREE;
2461           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2462         }
2463       TREE_CHAIN (binding) = old_bindings;
2464       old_bindings = binding;
2465     skip_it:
2466       ;
2467     }
2468   return old_bindings;
2469 }
2470
2471 void
2472 maybe_push_to_top_level (pseudo)
2473      int pseudo;
2474 {
2475   struct saved_scope *s;
2476   struct binding_level *b;
2477   tree old_bindings;
2478   int need_pop;
2479
2480   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2481
2482   b = scope_chain ? current_binding_level : 0;
2483
2484   /* If we're in the middle of some function, save our state.  */
2485   if (cfun)
2486     {
2487       need_pop = 1;
2488       push_function_context_to (NULL_TREE);
2489     }
2490   else
2491     need_pop = 0;
2492
2493   old_bindings = NULL_TREE;
2494   if (scope_chain && previous_class_type)
2495     old_bindings = store_bindings (previous_class_values, old_bindings);
2496
2497   /* Have to include global_binding_level, because class-level decls
2498      aren't listed anywhere useful.  */
2499   for (; b; b = b->level_chain)
2500     {
2501       tree t;
2502
2503       /* Template IDs are inserted into the global level. If they were
2504          inserted into namespace level, finish_file wouldn't find them
2505          when doing pending instantiations. Therefore, don't stop at
2506          namespace level, but continue until :: .  */
2507       if (b == global_binding_level || (pseudo && b->template_parms_p))
2508         break;
2509
2510       old_bindings = store_bindings (b->names, old_bindings);
2511       /* We also need to check class_shadowed to save class-level type
2512          bindings, since pushclass doesn't fill in b->names.  */
2513       if (b->parm_flag == 2)
2514         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2515
2516       /* Unwind type-value slots back to top level.  */
2517       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2518         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2519     }
2520   s->prev = scope_chain;
2521   s->old_bindings = old_bindings;
2522   s->bindings = b;
2523   s->need_pop_function_context = need_pop;
2524   s->function_decl = current_function_decl;
2525
2526   scope_chain = s;
2527   current_function_decl = NULL_TREE;
2528   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2529   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2530   current_lang_name = lang_name_cplusplus;
2531   strict_prototype = strict_prototypes_lang_cplusplus;
2532   current_namespace = global_namespace;
2533 }
2534
2535 void
2536 push_to_top_level ()
2537 {
2538   maybe_push_to_top_level (0);
2539 }
2540
2541 void
2542 pop_from_top_level ()
2543 {
2544   struct saved_scope *s = scope_chain;
2545   tree t;
2546
2547   /* Clear out class-level bindings cache.  */
2548   if (previous_class_type)
2549     invalidate_class_lookup_cache ();
2550
2551   VARRAY_FREE (current_lang_base);
2552
2553   scope_chain = s->prev;
2554   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2555     {
2556       tree id = TREE_VEC_ELT (t, 0);
2557       if (id)
2558         {
2559           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2560           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2561           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2562         }
2563     }
2564
2565   if (current_lang_name == lang_name_cplusplus)
2566     strict_prototype = strict_prototypes_lang_cplusplus;
2567   else if (current_lang_name == lang_name_c)
2568     strict_prototype = strict_prototypes_lang_c;
2569
2570   /* If we were in the middle of compiling a function, restore our
2571      state.  */
2572   if (s->need_pop_function_context)
2573     pop_function_context_from (NULL_TREE);
2574   current_function_decl = s->function_decl;
2575
2576   free (s);
2577 }
2578 \f
2579 /* Push a definition of struct, union or enum tag "name".
2580    into binding_level "b".   "type" should be the type node,
2581    We assume that the tag "name" is not already defined.
2582
2583    Note that the definition may really be just a forward reference.
2584    In that case, the TYPE_SIZE will be a NULL_TREE.
2585
2586    C++ gratuitously puts all these tags in the name space.  */
2587
2588 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2589    record the shadowed value for this binding contour.  TYPE is
2590    the type that ID maps to.  */
2591
2592 static void
2593 set_identifier_type_value_with_scope (id, type, b)
2594      tree id;
2595      tree type;
2596      struct binding_level *b;
2597 {
2598   if (!b->namespace_p)
2599     {
2600       /* Shadow the marker, not the real thing, so that the marker
2601          gets restored later. */
2602       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2603       b->type_shadowed
2604         = tree_cons (id, old_type_value, b->type_shadowed);
2605     }
2606   else
2607     {
2608       tree binding = binding_for_name (id, current_namespace);
2609       BINDING_TYPE (binding) = type;
2610       /* Store marker instead of real type. */
2611       type = global_type_node;
2612     }
2613   SET_IDENTIFIER_TYPE_VALUE (id, type);
2614 }
2615
2616 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2617
2618 void
2619 set_identifier_type_value (id, type)
2620      tree id;
2621      tree type;
2622 {
2623   set_identifier_type_value_with_scope (id, type, current_binding_level);
2624 }
2625
2626 /* Return the type associated with id. */
2627
2628 tree
2629 identifier_type_value (id)
2630      tree id;
2631 {
2632   /* There is no type with that name, anywhere. */
2633   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2634     return NULL_TREE;
2635   /* This is not the type marker, but the real thing. */
2636   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2637     return REAL_IDENTIFIER_TYPE_VALUE (id);
2638   /* Have to search for it. It must be on the global level, now.
2639      Ask lookup_name not to return non-types. */
2640   id = lookup_name_real (id, 2, 1, 0);
2641   if (id)
2642     return TREE_TYPE (id);
2643   return NULL_TREE;
2644 }
2645
2646 /* Pop off extraneous binding levels left over due to syntax errors.
2647
2648    We don't pop past namespaces, as they might be valid.  */
2649
2650 void
2651 pop_everything ()
2652 {
2653 #ifdef DEBUG_CP_BINDING_LEVELS
2654   fprintf (stderr, "XXX entering pop_everything ()\n");
2655 #endif
2656   while (!toplevel_bindings_p ())
2657     {
2658       if (current_binding_level->parm_flag == 2)
2659         pop_nested_class ();
2660       else
2661         poplevel (0, 0, 0);
2662     }
2663 #ifdef DEBUG_CP_BINDING_LEVELS
2664   fprintf (stderr, "XXX leaving pop_everything ()\n");
2665 #endif
2666 }
2667
2668 /* The type TYPE is being declared.  If it is a class template, or a
2669    specialization of a class template, do any processing required and
2670    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2671    being declared a friend.  B is the binding level at which this TYPE
2672    should be bound.
2673
2674    Returns the TYPE_DECL for TYPE, which may have been altered by this
2675    processing.  */
2676
2677 static tree
2678 maybe_process_template_type_declaration (type, globalize, b)
2679      tree type;
2680      int globalize;
2681      struct binding_level* b;
2682 {
2683   tree decl = TYPE_NAME (type);
2684
2685   if (processing_template_parmlist)
2686     /* You can't declare a new template type in a template parameter
2687        list.  But, you can declare a non-template type:
2688
2689          template <class A*> struct S;
2690
2691        is a forward-declaration of `A'.  */
2692     ;
2693   else
2694     {
2695       maybe_check_template_type (type);
2696
2697       my_friendly_assert (IS_AGGR_TYPE (type)
2698                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2699
2700
2701       if (processing_template_decl)
2702         {
2703           /* This may change after the call to
2704              push_template_decl_real, but we want the original value.  */
2705           tree name = DECL_NAME (decl);
2706
2707           decl = push_template_decl_real (decl, globalize);
2708           /* If the current binding level is the binding level for the
2709              template parameters (see the comment in
2710              begin_template_parm_list) and the enclosing level is a class
2711              scope, and we're not looking at a friend, push the
2712              declaration of the member class into the class scope.  In the
2713              friend case, push_template_decl will already have put the
2714              friend into global scope, if appropriate.  */
2715           if (TREE_CODE (type) != ENUMERAL_TYPE
2716               && !globalize && b->template_parms_p
2717               && b->level_chain->parm_flag == 2)
2718             {
2719               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2720               /* Put this tag on the list of tags for the class, since
2721                  that won't happen below because B is not the class
2722                  binding level, but is instead the pseudo-global level.  */
2723               b->level_chain->tags =
2724                 tree_cons (name, type, b->level_chain->tags);
2725               if (!COMPLETE_TYPE_P (current_class_type))
2726                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2727             }
2728         }
2729     }
2730
2731   return decl;
2732 }
2733
2734 /* In C++, you don't have to write `struct S' to refer to `S'; you
2735    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2736    if the user had written `typedef struct S S'.  Create and return
2737    the TYPE_DECL for TYPE.  */
2738
2739 tree
2740 create_implicit_typedef (name, type)
2741      tree name;
2742      tree type;
2743 {
2744   tree decl;
2745
2746   decl = build_decl (TYPE_DECL, name, type);
2747   SET_DECL_ARTIFICIAL (decl);
2748   /* There are other implicit type declarations, like the one *within*
2749      a class that allows you to write `S::S'.  We must distinguish
2750      amongst these.  */
2751   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2752   TYPE_NAME (type) = decl;
2753
2754   return decl;
2755 }
2756
2757 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2758    Normally put it into the inner-most non-tag-transparent scope,
2759    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2760    The latter is needed for implicit declarations.  */
2761
2762 void
2763 pushtag (name, type, globalize)
2764      tree name, type;
2765      int globalize;
2766 {
2767   register struct binding_level *b;
2768
2769   b = current_binding_level;
2770   while (b->tag_transparent
2771          || (globalize && b->parm_flag == 2))
2772     b = b->level_chain;
2773
2774   b->tags = tree_cons (name, type, b->tags);
2775
2776   if (name)
2777     {
2778       /* Do C++ gratuitous typedefing.  */
2779       if (IDENTIFIER_TYPE_VALUE (name) != type)
2780         {
2781           register tree d = NULL_TREE;
2782           int in_class = 0;
2783           tree context = TYPE_CONTEXT (type);
2784
2785           if (! context)
2786             {
2787               tree cs = current_scope ();
2788
2789               if (! globalize)
2790                 context = cs;
2791               else if (cs != NULL_TREE
2792                        && TREE_CODE_CLASS (TREE_CODE (cs)) == 't')
2793                 /* When declaring a friend class of a local class, we want
2794                    to inject the newly named class into the scope
2795                    containing the local class, not the namespace scope.  */
2796                 context = decl_function_context (get_type_decl (cs));
2797             }
2798           if (!context)
2799             context = current_namespace;
2800
2801           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2802               || b->parm_flag == 2)
2803             in_class = 1;
2804
2805           if (current_lang_name == lang_name_java)
2806             TYPE_FOR_JAVA (type) = 1;
2807
2808           d = create_implicit_typedef (name, type);
2809           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2810           if (! in_class)
2811             set_identifier_type_value_with_scope (name, type, b);
2812
2813           d = maybe_process_template_type_declaration (type,
2814                                                        globalize, b);
2815
2816           if (b->parm_flag == 2)
2817             {
2818               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2819                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2820                    class.  But if it's a member template class, we
2821                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2822                    is done later.  */
2823                 finish_member_declaration (d);
2824               else
2825                 pushdecl_class_level (d);
2826             }
2827           else
2828             d = pushdecl_with_scope (d, b);
2829
2830           if (ANON_AGGRNAME_P (name))
2831             DECL_IGNORED_P (d) = 1;
2832
2833           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2834           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2835           if (!uses_template_parms (type))
2836             DECL_ASSEMBLER_NAME (d)
2837               = get_identifier (build_overload_name (type, 1, 1));
2838         }
2839       if (b->parm_flag == 2)
2840         {
2841           if (!COMPLETE_TYPE_P (current_class_type))
2842             CLASSTYPE_TAGS (current_class_type) = b->tags;
2843         }
2844     }
2845
2846   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2847     /* Use the canonical TYPE_DECL for this node.  */
2848     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2849   else
2850     {
2851       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2852          will be the tagged type we just added to the current
2853          binding level.  This fake NULL-named TYPE_DECL node helps
2854          dwarfout.c to know when it needs to output a
2855          representation of a tagged type, and it also gives us a
2856          convenient place to record the "scope start" address for
2857          the tagged type.  */
2858
2859       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2860       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2861     }
2862 }
2863
2864 /* Counter used to create anonymous type names.  */
2865
2866 static int anon_cnt = 0;
2867
2868 /* Return an IDENTIFIER which can be used as a name for
2869    anonymous structs and unions.  */
2870
2871 tree
2872 make_anon_name ()
2873 {
2874   char buf[32];
2875
2876   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2877   return get_identifier (buf);
2878 }
2879
2880 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2881    This keeps dbxout from getting confused.  */
2882
2883 void
2884 clear_anon_tags ()
2885 {
2886   register struct binding_level *b;
2887   register tree tags;
2888   static int last_cnt = 0;
2889
2890   /* Fast out if no new anon names were declared.  */
2891   if (last_cnt == anon_cnt)
2892     return;
2893
2894   b = current_binding_level;
2895   while (b->tag_transparent)
2896     b = b->level_chain;
2897   tags = b->tags;
2898   while (tags)
2899     {
2900       /* A NULL purpose means we have already processed all tags
2901          from here to the end of the list.  */
2902       if (TREE_PURPOSE (tags) == NULL_TREE)
2903         break;
2904       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2905         TREE_PURPOSE (tags) = NULL_TREE;
2906       tags = TREE_CHAIN (tags);
2907     }
2908   last_cnt = anon_cnt;
2909 }
2910 \f
2911 /* Subroutine of duplicate_decls: return truthvalue of whether
2912    or not types of these decls match.
2913
2914    For C++, we must compare the parameter list so that `int' can match
2915    `int&' in a parameter position, but `int&' is not confused with
2916    `const int&'.  */
2917
2918 int
2919 decls_match (newdecl, olddecl)
2920      tree newdecl, olddecl;
2921 {
2922   int types_match;
2923
2924   if (newdecl == olddecl)
2925     return 1;
2926
2927   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2928     /* If the two DECLs are not even the same kind of thing, we're not
2929        interested in their types.  */
2930     return 0;
2931
2932   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2933     {
2934       tree f1 = TREE_TYPE (newdecl);
2935       tree f2 = TREE_TYPE (olddecl);
2936       tree p1 = TYPE_ARG_TYPES (f1);
2937       tree p2 = TYPE_ARG_TYPES (f2);
2938
2939       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2940           && ! (DECL_LANGUAGE (newdecl) == lang_c
2941                 && DECL_LANGUAGE (olddecl) == lang_c))
2942         return 0;
2943
2944       if (TREE_CODE (f1) != TREE_CODE (f2))
2945         return 0;
2946
2947       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2948         {
2949           if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2950               && p2 == NULL_TREE)
2951             {
2952               types_match = self_promoting_args_p (p1);
2953               if (p1 == void_list_node)
2954                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2955             }
2956           else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2957                    && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2958             {
2959               types_match = self_promoting_args_p (p2);
2960               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2961             }
2962           else
2963             types_match = compparms (p1, p2);
2964         }
2965       else
2966         types_match = 0;
2967     }
2968   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2969     {
2970       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2971                                 DECL_TEMPLATE_PARMS (olddecl)))
2972         return 0;
2973
2974       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2975         types_match = 1;
2976       else
2977         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2978                                    DECL_TEMPLATE_RESULT (newdecl));
2979     }
2980   else
2981     {
2982       if (TREE_TYPE (newdecl) == error_mark_node)
2983         types_match = TREE_TYPE (olddecl) == error_mark_node;
2984       else if (TREE_TYPE (olddecl) == NULL_TREE)
2985         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2986       else if (TREE_TYPE (newdecl) == NULL_TREE)
2987         types_match = 0;
2988       else
2989         types_match = comptypes (TREE_TYPE (newdecl),
2990                                  TREE_TYPE (olddecl),
2991                                  COMPARE_REDECLARATION);
2992     }
2993
2994   return types_match;
2995 }
2996
2997 /* If NEWDECL is `static' and an `extern' was seen previously,
2998    warn about it.  OLDDECL is the previous declaration.
2999
3000    Note that this does not apply to the C++ case of declaring
3001    a variable `extern const' and then later `const'.
3002
3003    Don't complain about built-in functions, since they are beyond
3004    the user's control.  */
3005
3006 static void
3007 warn_extern_redeclared_static (newdecl, olddecl)
3008      tree newdecl, olddecl;
3009 {
3010   static const char *explicit_extern_static_warning
3011     = "`%D' was declared `extern' and later `static'";
3012   static const char *implicit_extern_static_warning
3013     = "`%D' was declared implicitly `extern' and later `static'";
3014
3015   tree name;
3016
3017   if (TREE_CODE (newdecl) == TYPE_DECL
3018       || TREE_CODE (newdecl) == TEMPLATE_DECL)
3019     return;
3020
3021   /* Don't get confused by static member functions; that's a different
3022      use of `static'.  */
3023   if (TREE_CODE (newdecl) == FUNCTION_DECL
3024       && DECL_STATIC_FUNCTION_P (newdecl))
3025     return;
3026
3027   /* If the old declaration was `static', or the new one isn't, then
3028      then everything is OK.  */
3029   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3030     return;
3031
3032   /* It's OK to declare a builtin function as `static'.  */
3033   if (TREE_CODE (olddecl) == FUNCTION_DECL
3034       && DECL_ARTIFICIAL (olddecl))
3035     return;
3036
3037   name = DECL_ASSEMBLER_NAME (newdecl);
3038   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3039               ? implicit_extern_static_warning
3040               : explicit_extern_static_warning, newdecl);
3041   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3042 }
3043
3044 /* Handle when a new declaration NEWDECL has the same name as an old
3045    one OLDDECL in the same binding contour.  Prints an error message
3046    if appropriate.
3047
3048    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3049    Otherwise, return 0.  */
3050
3051 int
3052 duplicate_decls (newdecl, olddecl)
3053      tree newdecl, olddecl;
3054 {
3055   unsigned olddecl_uid = DECL_UID (olddecl);
3056   int olddecl_friend = 0, types_match = 0;
3057   int new_defines_function = 0;
3058
3059   if (newdecl == olddecl)
3060     return 1;
3061
3062   types_match = decls_match (newdecl, olddecl);
3063
3064   /* If either the type of the new decl or the type of the old decl is an
3065      error_mark_node, then that implies that we have already issued an
3066      error (earlier) for some bogus type specification, and in that case,
3067      it is rather pointless to harass the user with yet more error message
3068      about the same declaration, so just pretend the types match here.  */
3069   if (TREE_TYPE (newdecl) == error_mark_node
3070       || TREE_TYPE (olddecl) == error_mark_node)
3071     types_match = 1;
3072
3073   /* Check for redeclaration and other discrepancies. */
3074   if (TREE_CODE (olddecl) == FUNCTION_DECL
3075       && DECL_ARTIFICIAL (olddecl))
3076     {
3077       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3078         {
3079           /* If you declare a built-in or predefined function name as static,
3080              the old definition is overridden, but optionally warn this was a
3081              bad choice of name.  */
3082           if (! TREE_PUBLIC (newdecl))
3083             {
3084               if (warn_shadow)
3085                 cp_warning ("shadowing %s function `%#D'",
3086                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3087                             olddecl);
3088               /* Discard the old built-in function.  */
3089               return 0;
3090             }
3091           /* If the built-in is not ansi, then programs can override
3092              it even globally without an error.  */
3093           else if (! DECL_BUILT_IN (olddecl))
3094             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3095                         olddecl, newdecl);
3096           else
3097             {
3098               cp_error ("declaration of `%#D'", newdecl);
3099               cp_error ("conflicts with built-in declaration `%#D'",
3100                         olddecl);
3101             }
3102           return 0;
3103         }
3104       else if (!types_match)
3105         {
3106           if ((DECL_LANGUAGE (newdecl) == lang_c
3107                && DECL_LANGUAGE (olddecl) == lang_c)
3108               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3109                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3110             {
3111               /* A near match; override the builtin.  */
3112
3113               if (TREE_PUBLIC (newdecl))
3114                 {
3115                   cp_warning ("new declaration `%#D'", newdecl);
3116                   cp_warning ("ambiguates built-in declaration `%#D'",
3117                               olddecl);
3118                 }
3119               else if (warn_shadow)
3120                 cp_warning ("shadowing %s function `%#D'",
3121                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3122                             olddecl);
3123             }
3124           else
3125             /* Discard the old built-in function.  */
3126             return 0;
3127         }
3128
3129       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3130         {
3131           /* If a builtin function is redeclared as `static', merge
3132              the declarations, but make the original one static.  */
3133           DECL_THIS_STATIC (olddecl) = 1;
3134           TREE_PUBLIC (olddecl) = 0;
3135
3136           /* Make the olddeclaration consistent with the new one so that
3137              all remnants of the builtin-ness of this function will be
3138              banished.  */
3139           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3140           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3141           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3142           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3143                                        newdecl);
3144         }
3145     }
3146   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3147     {
3148       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3149            && TREE_CODE (newdecl) != TYPE_DECL
3150            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3151                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3152           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3153               && TREE_CODE (olddecl) != TYPE_DECL
3154               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3155                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3156                         == TYPE_DECL))))
3157         {
3158           /* We do nothing special here, because C++ does such nasty
3159              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3160              get shadowed, and know that if we need to find a TYPE_DECL
3161              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3162              slot of the identifier.  */
3163           return 0;
3164         }
3165
3166       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3167            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3168           || (TREE_CODE (olddecl) == FUNCTION_DECL
3169               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3170         return 0;
3171
3172       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3173       if (TREE_CODE (olddecl) == TREE_LIST)
3174         olddecl = TREE_VALUE (olddecl);
3175       cp_error_at ("previous declaration of `%#D'", olddecl);
3176
3177       /* New decl is completely inconsistent with the old one =>
3178          tell caller to replace the old one.  */
3179
3180       return 0;
3181     }
3182   else if (!types_match)
3183     {
3184       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3185         /* These are certainly not duplicate declarations; they're
3186            from different scopes.  */
3187         return 0;
3188
3189       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3190         {
3191           /* The name of a class template may not be declared to refer to
3192              any other template, class, function, object, namespace, value,
3193              or type in the same scope.  */
3194           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3195               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3196             {
3197               cp_error ("declaration of template `%#D'", newdecl);
3198               cp_error_at ("conflicts with previous declaration `%#D'",
3199                            olddecl);
3200             }
3201           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3202                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3203                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3204                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3205                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3206                                            DECL_TEMPLATE_PARMS (olddecl)))
3207             {
3208               cp_error ("new declaration `%#D'", newdecl);
3209               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3210             }
3211           return 0;
3212         }
3213       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3214         {
3215           if (DECL_LANGUAGE (newdecl) == lang_c
3216               && DECL_LANGUAGE (olddecl) == lang_c)
3217             {
3218               cp_error ("declaration of C function `%#D' conflicts with",
3219                         newdecl);
3220               cp_error_at ("previous declaration `%#D' here", olddecl);
3221             }
3222           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3223                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3224             {
3225               cp_error ("new declaration `%#D'", newdecl);
3226               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3227             }
3228           else
3229             return 0;
3230         }
3231
3232       /* Already complained about this, so don't do so again.  */
3233       else if (current_class_type == NULL_TREE
3234           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3235         {
3236           cp_error ("conflicting types for `%#D'", newdecl);
3237           cp_error_at ("previous declaration as `%#D'", olddecl);
3238         }
3239     }
3240   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3241             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3242                  && (!DECL_TEMPLATE_INFO (newdecl)
3243                      || (DECL_TI_TEMPLATE (newdecl)
3244                          != DECL_TI_TEMPLATE (olddecl))))
3245                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3246                     && (!DECL_TEMPLATE_INFO (olddecl)
3247                         || (DECL_TI_TEMPLATE (olddecl)
3248                             != DECL_TI_TEMPLATE (newdecl))))))
3249     /* It's OK to have a template specialization and a non-template
3250        with the same type, or to have specializations of two
3251        different templates with the same type.  Note that if one is a
3252        specialization, and the other is an instantiation of the same
3253        template, that we do not exit at this point.  That situation
3254        can occur if we instantiate a template class, and then
3255        specialize one of its methods.  This situation is legal, but
3256        the declarations must be merged in the usual way.  */
3257     return 0;
3258   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3259            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3260                 && !DECL_USE_TEMPLATE (newdecl))
3261                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3262                    && !DECL_USE_TEMPLATE (olddecl))))
3263     /* One of the declarations is a template instantiation, and the
3264        other is not a template at all.  That's OK.  */
3265     return 0;
3266   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3267            && DECL_NAMESPACE_ALIAS (newdecl)
3268            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3269     /* Redeclaration of namespace alias, ignore it. */
3270     return 1;
3271   else
3272     {
3273       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3274       if (errmsg)
3275         {
3276           cp_error (errmsg, newdecl);
3277           if (DECL_NAME (olddecl) != NULL_TREE)
3278             cp_error_at ((DECL_INITIAL (olddecl)
3279                           && namespace_bindings_p ())
3280                          ? "`%#D' previously defined here"
3281                          : "`%#D' previously declared here", olddecl);
3282         }
3283       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3284                && DECL_INITIAL (olddecl) != NULL_TREE
3285                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3286                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3287         {
3288           /* Prototype decl follows defn w/o prototype.  */
3289           cp_warning_at ("prototype for `%#D'", newdecl);
3290           cp_warning_at ("follows non-prototype definition here", olddecl);
3291         }
3292       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3293                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3294         {
3295           /* extern "C" int foo ();
3296              int foo () { bar (); }
3297              is OK.  */
3298           if (current_lang_stack
3299               == &VARRAY_TREE (current_lang_base, 0))
3300             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3301           else
3302             {
3303               cp_error_at ("previous declaration of `%#D' with %L linkage",
3304                            olddecl, DECL_LANGUAGE (olddecl));
3305               cp_error ("conflicts with new declaration with %L linkage",
3306                         DECL_LANGUAGE (newdecl));
3307             }
3308         }
3309
3310       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3311         ;
3312       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3313         {
3314           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3315           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3316           int i = 1;
3317
3318           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3319             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3320
3321           for (; t1 && t1 != void_list_node;
3322                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3323             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3324               {
3325                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3326                                            TREE_PURPOSE (t2)))
3327                   {
3328                     if (pedantic)
3329                       {
3330                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3331                                     i, newdecl);
3332                         cp_pedwarn_at ("after previous specification in `%#D'",
3333                                        olddecl);
3334                       }
3335                   }
3336                 else
3337                   {
3338                     cp_error ("default argument given for parameter %d of `%#D'",
3339                               i, newdecl);
3340                     cp_error_at ("after previous specification in `%#D'",
3341                                  olddecl);
3342                   }
3343               }
3344
3345           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3346               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3347             {
3348               cp_warning ("`%#D' was used before it was declared inline",
3349                           newdecl);
3350               cp_warning_at ("previous non-inline declaration here",
3351                              olddecl);
3352             }
3353         }
3354     }
3355
3356   /* If new decl is `static' and an `extern' was seen previously,
3357      warn about it.  */
3358   warn_extern_redeclared_static (newdecl, olddecl);
3359
3360   /* We have committed to returning 1 at this point.  */
3361   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3362     {
3363       /* Now that functions must hold information normally held
3364          by field decls, there is extra work to do so that
3365          declaration information does not get destroyed during
3366          definition.  */
3367       if (DECL_VINDEX (olddecl))
3368         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3369       if (DECL_VIRTUAL_CONTEXT (olddecl))
3370         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3371       if (DECL_CONTEXT (olddecl))
3372         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3373       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3374         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3375       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3376       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3377       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3378       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3379       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3380       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3381       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3382
3383       /* Optionally warn about more than one declaration for the same
3384          name, but don't warn about a function declaration followed by a
3385          definition.  */
3386       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3387           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3388           /* Don't warn about extern decl followed by definition. */
3389           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3390           /* Don't warn about friends, let add_friend take care of it. */
3391           && ! DECL_FRIEND_P (newdecl))
3392         {
3393           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3394           cp_warning_at ("previous declaration of `%D'", olddecl);
3395         }
3396     }
3397
3398   /* Deal with C++: must preserve virtual function table size.  */
3399   if (TREE_CODE (olddecl) == TYPE_DECL)
3400     {
3401       register tree newtype = TREE_TYPE (newdecl);
3402       register tree oldtype = TREE_TYPE (olddecl);
3403
3404       if (newtype != error_mark_node && oldtype != error_mark_node
3405           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3406         {
3407           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3408           CLASSTYPE_FRIEND_CLASSES (newtype)
3409             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3410         }
3411     }
3412
3413   /* Copy all the DECL_... slots specified in the new decl
3414      except for any that we copy here from the old type.  */
3415   DECL_MACHINE_ATTRIBUTES (newdecl)
3416     = merge_machine_decl_attributes (olddecl, newdecl);
3417
3418   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3419     {
3420       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3421                              DECL_TEMPLATE_RESULT (olddecl)))
3422         cp_error ("invalid redeclaration of %D", newdecl);
3423       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3424       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3425         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3426                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3427
3428       return 1;
3429     }
3430
3431   if (types_match)
3432     {
3433       /* Automatically handles default parameters.  */
3434       tree oldtype = TREE_TYPE (olddecl);
3435       tree newtype;
3436
3437       /* Merge the data types specified in the two decls.  */
3438       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3439
3440       if (TREE_CODE (newdecl) == VAR_DECL)
3441         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3442       /* Do this after calling `common_type' so that default
3443          parameters don't confuse us.  */
3444       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3445           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3446               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3447         {
3448           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3449                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3450           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3451                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3452
3453           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3454               && DECL_SOURCE_LINE (olddecl) != 0
3455               && flag_exceptions
3456               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3457                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3458             {
3459               cp_error ("declaration of `%F' throws different exceptions",
3460                         newdecl);
3461               cp_error_at ("than previous declaration `%F'", olddecl);
3462             }
3463         }
3464       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3465
3466       /* Lay the type out, unless already done.  */
3467       if (! same_type_p (newtype, oldtype)
3468           && TREE_TYPE (newdecl) != error_mark_node
3469           && !(processing_template_decl && uses_template_parms (newdecl)))
3470         layout_type (TREE_TYPE (newdecl));
3471
3472       if ((TREE_CODE (newdecl) == VAR_DECL
3473            || TREE_CODE (newdecl) == PARM_DECL
3474            || TREE_CODE (newdecl) == RESULT_DECL
3475            || TREE_CODE (newdecl) == FIELD_DECL
3476            || TREE_CODE (newdecl) == TYPE_DECL)
3477           && !(processing_template_decl && uses_template_parms (newdecl)))
3478         layout_decl (newdecl, 0);
3479
3480       /* Merge the type qualifiers.  */
3481       if (TREE_READONLY (newdecl))
3482         TREE_READONLY (olddecl) = 1;
3483       if (TREE_THIS_VOLATILE (newdecl))
3484         TREE_THIS_VOLATILE (olddecl) = 1;
3485
3486       /* Merge the initialization information.  */
3487       if (DECL_INITIAL (newdecl) == NULL_TREE
3488           && DECL_INITIAL (olddecl) != NULL_TREE)
3489         {
3490           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3491           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3492           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3493           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3494               && DECL_LANG_SPECIFIC (newdecl)
3495               && DECL_LANG_SPECIFIC (olddecl))
3496             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3497         }
3498
3499       /* Merge the section attribute.
3500          We want to issue an error if the sections conflict but that must be
3501          done later in decl_attributes since we are called before attributes
3502          are assigned.  */
3503       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3504         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3505
3506       /* Keep the old rtl since we can safely use it.  */
3507       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3508
3509       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3510         {
3511           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3512             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3513           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3514             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3515           DECL_NO_LIMIT_STACK (newdecl)
3516             |= DECL_NO_LIMIT_STACK (olddecl);
3517         }
3518     }
3519   /* If cannot merge, then use the new type and qualifiers,
3520      and don't preserve the old rtl.  */
3521   else
3522     {
3523       /* Clean out any memory we had of the old declaration.  */
3524       tree oldstatic = value_member (olddecl, static_aggregates);
3525       if (oldstatic)
3526         TREE_VALUE (oldstatic) = error_mark_node;
3527
3528       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3529       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3530       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3531       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3532     }
3533
3534   /* Merge the storage class information.  */
3535   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3536   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3537   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3538   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3539   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3540   if (! DECL_EXTERNAL (olddecl))
3541     DECL_EXTERNAL (newdecl) = 0;
3542
3543   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3544     {
3545       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3546       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3547       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3548       DECL_TEMPLATE_INSTANTIATED (newdecl)
3549         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3550       /* Don't really know how much of the language-specific
3551          values we should copy from old to new.  */
3552       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3553       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3554       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3555       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3556       olddecl_friend = DECL_FRIEND_P (olddecl);
3557
3558       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3559       if (TREE_CODE (newdecl) == FUNCTION_DECL
3560           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3561         DECL_BEFRIENDING_CLASSES (newdecl)
3562           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3563                      DECL_BEFRIENDING_CLASSES (olddecl));
3564     }
3565
3566   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3567     {
3568       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3569           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3570         {
3571           /* If newdecl is not a specialization, then it is not a
3572              template-related function at all.  And that means that we
3573              shoud have exited above, returning 0.  */
3574           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3575                               0);
3576
3577           if (TREE_USED (olddecl))
3578             /* From [temp.expl.spec]:
3579
3580                If a template, a member template or the member of a class
3581                template is explicitly specialized then that
3582                specialization shall be declared before the first use of
3583                that specialization that would cause an implicit
3584                instantiation to take place, in every translation unit in
3585                which such a use occurs.  */
3586             cp_error ("explicit specialization of %D after first use",
3587                       olddecl);
3588
3589           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3590         }
3591       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3592
3593       /* If either decl says `inline', this fn is inline, unless its
3594          definition was passed already.  */
3595       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3596         DECL_INLINE (olddecl) = 1;
3597       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3598
3599       if (! types_match)
3600         {
3601           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3602           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3603           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3604         }
3605       if (! types_match || new_defines_function)
3606         {
3607           /* These need to be copied so that the names are available.
3608              Note that if the types do match, we'll preserve inline
3609              info and other bits, but if not, we won't.  */
3610           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3611           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3612         }
3613       if (new_defines_function)
3614         /* If defining a function declared with other language
3615            linkage, use the previously declared language linkage.  */
3616         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3617       else if (types_match)
3618         {
3619           /* If redeclaring a builtin function, and not a definition,
3620              it stays built in.  */
3621           if (DECL_BUILT_IN (olddecl))
3622             {
3623               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3624               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3625               /* If we're keeping the built-in definition, keep the rtl,
3626                  regardless of declaration matches.  */
3627               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3628             }
3629           else
3630             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3631
3632           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3633           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3634             /* Previously saved insns go together with
3635                the function's previous definition.  */
3636             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3637           /* Don't clear out the arguments if we're redefining a function.  */
3638           if (DECL_ARGUMENTS (olddecl))
3639             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3640         }
3641       if (DECL_LANG_SPECIFIC (olddecl))
3642         DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
3643     }
3644
3645   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3646     {
3647       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3648     }
3649
3650   /* Now preserve various other info from the definition.  */
3651   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3652   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3653   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3654   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3655
3656   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3657     {
3658       int function_size;
3659
3660       function_size = sizeof (struct tree_decl);
3661
3662       bcopy ((char *) newdecl + sizeof (struct tree_common),
3663              (char *) olddecl + sizeof (struct tree_common),
3664              function_size - sizeof (struct tree_common));
3665
3666       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3667         {
3668           /* If newdecl is a template instantiation, it is possible that
3669              the following sequence of events has occurred:
3670
3671              o A friend function was declared in a class template.  The
3672              class template was instantiated.
3673
3674              o The instantiation of the friend declaration was
3675              recorded on the instantiation list, and is newdecl.
3676
3677              o Later, however, instantiate_class_template called pushdecl
3678              on the newdecl to perform name injection.  But, pushdecl in
3679              turn called duplicate_decls when it discovered that another
3680              declaration of a global function with the same name already
3681              existed.
3682
3683              o Here, in duplicate_decls, we decided to clobber newdecl.
3684
3685              If we're going to do that, we'd better make sure that
3686              olddecl, and not newdecl, is on the list of
3687              instantiations so that if we try to do the instantiation
3688              again we won't get the clobbered declaration.  */
3689
3690           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3691           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3692
3693           for (; decls; decls = TREE_CHAIN (decls))
3694             if (TREE_VALUE (decls) == newdecl)
3695               TREE_VALUE (decls) = olddecl;
3696         }
3697     }
3698   else
3699     {
3700       bcopy ((char *) newdecl + sizeof (struct tree_common),
3701              (char *) olddecl + sizeof (struct tree_common),
3702              sizeof (struct tree_decl) - sizeof (struct tree_common)
3703              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3704     }
3705
3706   DECL_UID (olddecl) = olddecl_uid;
3707   if (olddecl_friend)
3708     DECL_FRIEND_P (olddecl) = 1;
3709
3710   /* NEWDECL contains the merged attribute lists.
3711      Update OLDDECL to be the same.  */
3712   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3713
3714   return 1;
3715 }
3716
3717 /* Record a decl-node X as belonging to the current lexical scope.
3718    Check for errors (such as an incompatible declaration for the same
3719    name already seen in the same scope).
3720
3721    Returns either X or an old decl for the same name.
3722    If an old decl is returned, it may have been smashed
3723    to agree with what X says.  */
3724
3725 tree
3726 pushdecl (x)
3727      tree x;
3728 {
3729   register tree t;
3730   register tree name;
3731   int need_new_binding;
3732
3733   /* We shouldn't be calling pushdecl when we're generating RTL for a
3734      function that we already did semantic analysis on previously.  */
3735   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3736                       19990913);
3737
3738   name = DECL_ASSEMBLER_NAME (x);
3739   need_new_binding = 1;
3740
3741   if (DECL_TEMPLATE_PARM_P (x))
3742     /* Template parameters have no context; they are not X::T even
3743        when declared within a class or namespace.  */
3744     ;
3745   else
3746     {
3747       if (current_function_decl && x != current_function_decl
3748           /* A local declaration for a function doesn't constitute
3749              nesting.  */
3750           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3751           /* A local declaration for an `extern' variable is in the
3752              scoped of the current namespace, not the current
3753              function.  */
3754           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3755           && !DECL_CONTEXT (x))
3756         DECL_CONTEXT (x) = current_function_decl;
3757       if (!DECL_CONTEXT (x))
3758         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3759
3760       /* If this is the declaration for a namespace-scope function,
3761          but the declaration itself is in a local scope, mark the
3762          declaration.  */
3763       if (TREE_CODE (x) == FUNCTION_DECL
3764           && DECL_NAMESPACE_SCOPE_P (x)
3765           && current_function_decl
3766           && x != current_function_decl)
3767         DECL_LOCAL_FUNCTION_P (x) = 1;
3768     }
3769
3770   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3771      compiler wants to use.  */
3772   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3773       || TREE_CODE (x) == NAMESPACE_DECL)
3774     name = DECL_NAME (x);
3775
3776   if (name)
3777     {
3778 #if 0
3779       /* Not needed...see below.  */
3780       char *file;
3781       int line;
3782 #endif
3783       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3784         name = TREE_OPERAND (name, 0);
3785
3786       /* Namespace-scoped variables are not found in the current level. */
3787       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3788         t = namespace_binding (name, DECL_CONTEXT (x));
3789       else
3790         t = lookup_name_current_level (name);
3791       if (t == error_mark_node)
3792         {
3793           /* error_mark_node is 0 for a while during initialization!  */
3794           t = NULL_TREE;
3795           cp_error_at ("`%#D' used prior to declaration", x);
3796         }
3797
3798       else if (t != NULL_TREE)
3799         {
3800 #if 0
3801           /* This is turned off until I have time to do it right (bpk).  */
3802           /* With the code below that uses it...  */
3803           file = DECL_SOURCE_FILE (t);
3804           line = DECL_SOURCE_LINE (t);
3805 #endif
3806           if (TREE_CODE (t) == PARM_DECL)
3807             {
3808               if (DECL_CONTEXT (t) == NULL_TREE)
3809                 fatal ("parse errors have confused me too much");
3810
3811               /* Check for duplicate params.  */
3812               if (duplicate_decls (x, t))
3813                 return t;
3814             }
3815           else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3816                     || DECL_FUNCTION_TEMPLATE_P (x))
3817                    && is_overloaded_fn (t))
3818             /* Don't do anything just yet. */;
3819           else if (t == wchar_decl_node)
3820             {
3821               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3822                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3823
3824               /* Throw away the redeclaration.  */
3825               return t;
3826             }
3827           else if (TREE_CODE (t) != TREE_CODE (x))
3828             {
3829               if (duplicate_decls (x, t))
3830                 return t;
3831             }
3832           else if (duplicate_decls (x, t))
3833             {
3834 #if 0
3835               /* This is turned off until I have time to do it right (bpk).  */
3836
3837               /* Also warn if they did a prototype with `static' on it, but
3838                  then later left the `static' off.  */
3839               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3840                 {
3841                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3842                     return t;
3843
3844                   if (extra_warnings)
3845                     {
3846                       cp_warning ("`static' missing from declaration of `%D'",
3847                                   t);
3848                       warning_with_file_and_line (file, line,
3849                                                   "previous declaration of `%s'",
3850                                                   decl_as_string (t, 0));
3851                     }
3852
3853                   /* Now fix things so it'll do what they expect.  */
3854                   if (current_function_decl)
3855                     TREE_PUBLIC (current_function_decl) = 0;
3856                 }
3857               /* Due to interference in memory reclamation (X may be
3858                  obstack-deallocated at this point), we must guard against
3859                  one really special case.  [jason: This should be handled
3860                  by start_function]  */
3861               if (current_function_decl == x)
3862                 current_function_decl = t;
3863 #endif
3864               if (TREE_CODE (t) == TYPE_DECL)
3865                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3866               else if (TREE_CODE (t) == FUNCTION_DECL)
3867                 check_default_args (t);
3868
3869               return t;
3870             }
3871           else if (DECL_MAIN_P (x))
3872             {
3873               /* A redeclaration of main, but not a duplicate of the
3874                  previous one.
3875
3876                  [basic.start.main]
3877
3878                  This function shall not be overloaded.  */
3879               cp_error_at ("invalid redeclaration of `%D'", t);
3880               cp_error ("as `%D'", x);
3881               /* We don't try to push this declaration since that
3882                  causes a crash.  */
3883               return x;
3884             }
3885         }
3886
3887       check_template_shadow (x);
3888
3889       /* If this is a function conjured up by the backend, massage it
3890          so it looks friendly.  */
3891       if (TREE_CODE (x) == FUNCTION_DECL
3892           && ! DECL_LANG_SPECIFIC (x))
3893         {
3894           retrofit_lang_decl (x);
3895           DECL_LANGUAGE (x) = lang_c;
3896         }
3897
3898       if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3899         {
3900           t = push_overloaded_decl (x, PUSH_LOCAL);
3901           if (t != x)
3902             return t;
3903           if (!namespace_bindings_p ())
3904             /* We do not need to create a binding for this name;
3905                push_overloaded_decl will have already done so if
3906                necessary.  */
3907             need_new_binding = 0;
3908         }
3909       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3910         {
3911           t = push_overloaded_decl (x, PUSH_GLOBAL);
3912           if (t == x)
3913             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3914           return t;
3915         }
3916
3917       /* If declaring a type as a typedef, copy the type (unless we're
3918          at line 0), and install this TYPE_DECL as the new type's typedef
3919          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3920       if (TREE_CODE (x) == TYPE_DECL)
3921         {
3922           tree type = TREE_TYPE (x);
3923           if (DECL_SOURCE_LINE (x) == 0)
3924             {
3925               if (TYPE_NAME (type) == 0)
3926                 TYPE_NAME (type) = x;
3927             }
3928           else if (type != error_mark_node && TYPE_NAME (type) != x
3929                    /* We don't want to copy the type when all we're
3930                       doing is making a TYPE_DECL for the purposes of
3931                       inlining.  */
3932                    && (!TYPE_NAME (type)
3933                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3934             {
3935               DECL_ORIGINAL_TYPE (x) = type;
3936               type = build_type_copy (type);
3937               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3938               TYPE_NAME (type) = x;
3939               TREE_TYPE (x) = type;
3940             }
3941
3942           if (type != error_mark_node
3943               && TYPE_NAME (type)
3944               && TYPE_IDENTIFIER (type))
3945             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3946                                                   current_binding_level);
3947
3948         }
3949
3950       /* Multiple external decls of the same identifier ought to match.
3951
3952          We get warnings about inline functions where they are defined.
3953          We get warnings about other functions from push_overloaded_decl.
3954
3955          Avoid duplicate warnings where they are used.  */
3956       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3957         {
3958           tree decl;
3959
3960           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3961               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3962                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3963             decl = IDENTIFIER_NAMESPACE_VALUE (name);
3964           else
3965             decl = NULL_TREE;
3966
3967           if (decl
3968               /* If different sort of thing, we already gave an error.  */
3969               && TREE_CODE (decl) == TREE_CODE (x)
3970               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3971             {
3972               cp_pedwarn ("type mismatch with previous external decl", x);
3973               cp_pedwarn_at ("previous external decl of `%#D'", decl);
3974             }
3975         }
3976
3977       /* This name is new in its binding level.
3978          Install the new declaration and return it.  */
3979       if (namespace_bindings_p ())
3980         {
3981           /* Install a global value.  */
3982
3983           /* If the first global decl has external linkage,
3984              warn if we later see static one.  */
3985           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3986             TREE_PUBLIC (name) = 1;
3987
3988           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3989                 && t != NULL_TREE)
3990               /* For an ordinary function, we create a binding from
3991                  the mangled name (i.e., NAME) to the DECL.  But, for
3992                  an `extern "C"' function, the mangled name and the
3993                  ordinary name are the same so we need not do this.  */
3994               && !(TREE_CODE (x) == FUNCTION_DECL &&
3995                    DECL_LANGUAGE (x) == lang_c))
3996             {
3997               if (TREE_CODE (x) == FUNCTION_DECL)
3998                 my_friendly_assert
3999                   ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
4000                   || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
4001               SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4002             }
4003
4004           /* Don't forget if the function was used via an implicit decl.  */
4005           if (IDENTIFIER_IMPLICIT_DECL (name)
4006               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4007             TREE_USED (x) = 1;
4008
4009           /* Don't forget if its address was taken in that way.  */
4010           if (IDENTIFIER_IMPLICIT_DECL (name)
4011               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4012             TREE_ADDRESSABLE (x) = 1;
4013
4014           /* Warn about mismatches against previous implicit decl.  */
4015           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4016               /* If this real decl matches the implicit, don't complain.  */
4017               && ! (TREE_CODE (x) == FUNCTION_DECL
4018                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4019             cp_warning
4020               ("`%D' was previously implicitly declared to return `int'", x);
4021
4022           /* If new decl is `static' and an `extern' was seen previously,
4023              warn about it.  */
4024           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4025             warn_extern_redeclared_static (x, t);
4026         }
4027       else
4028         {
4029           /* Here to install a non-global value.  */
4030           tree oldlocal = IDENTIFIER_VALUE (name);
4031           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4032
4033           if (need_new_binding)
4034             {
4035               push_local_binding (name, x, 0);
4036               /* Because push_local_binding will hook X on to the
4037                  current_binding_level's name list, we don't want to
4038                  do that again below.  */
4039               need_new_binding = 0;
4040             }
4041
4042           /* If this is a TYPE_DECL, push it into the type value slot.  */
4043           if (TREE_CODE (x) == TYPE_DECL)
4044             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4045                                                   current_binding_level);
4046
4047           /* Clear out any TYPE_DECL shadowed by a namespace so that
4048              we won't think this is a type.  The C struct hack doesn't
4049              go through namespaces.  */
4050           if (TREE_CODE (x) == NAMESPACE_DECL)
4051             set_identifier_type_value_with_scope (name, NULL_TREE,
4052                                                   current_binding_level);
4053
4054           if (oldlocal)
4055             {
4056               tree d = oldlocal;
4057               while (oldlocal
4058                      && TREE_CODE (oldlocal) == VAR_DECL
4059                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4060                 {
4061                   oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4062                 }
4063               if (oldlocal == NULL_TREE)
4064                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4065             }
4066
4067           /* If this is an extern function declaration, see if we
4068              have a global definition or declaration for the function.  */
4069           if (oldlocal == NULL_TREE
4070               && DECL_EXTERNAL (x)
4071               && oldglobal != NULL_TREE
4072               && TREE_CODE (x) == FUNCTION_DECL
4073               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4074             {
4075               /* We have one.  Their types must agree.  */
4076               if (decls_match (x, oldglobal))
4077                 /* OK */;
4078               else
4079                 {
4080                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4081                   cp_warning_at ("global declaration `%#D'", oldglobal);
4082                 }
4083             }
4084           /* If we have a local external declaration,
4085              and no file-scope declaration has yet been seen,
4086              then if we later have a file-scope decl it must not be static.  */
4087           if (oldlocal == NULL_TREE
4088               && oldglobal == NULL_TREE
4089               && DECL_EXTERNAL (x)
4090               && TREE_PUBLIC (x))
4091             TREE_PUBLIC (name) = 1;
4092
4093           /* Warn if shadowing an argument at the top level of the body.  */
4094           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4095               /* Inline decls shadow nothing.  */
4096               && !DECL_FROM_INLINE (x)
4097               && TREE_CODE (oldlocal) == PARM_DECL
4098               /* Don't complain if it's from an enclosing function.  */
4099               && DECL_CONTEXT (oldlocal) == current_function_decl
4100               && TREE_CODE (x) != PARM_DECL)
4101             {
4102               /* Go to where the parms should be and see if we
4103                  find them there.  */
4104               struct binding_level *b = current_binding_level->level_chain;
4105
4106               if (cleanup_label)
4107                 b = b->level_chain;
4108
4109               /* ARM $8.3 */
4110               if (b->parm_flag == 1)
4111                 cp_error ("declaration of `%#D' shadows a parameter", name);
4112             }
4113
4114           /* Maybe warn if shadowing something else.  */
4115           if (warn_shadow && !DECL_EXTERNAL (x)
4116               /* Inline decls shadow nothing.  */
4117               && !DECL_FROM_INLINE (x)
4118               /* No shadow warnings for internally generated vars.  */
4119               && ! DECL_ARTIFICIAL (x)
4120               /* No shadow warnings for vars made for inlining.  */
4121               && ! DECL_FROM_INLINE (x))
4122             {
4123               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4124                 warning ("declaration of `%s' shadows a parameter",
4125                         IDENTIFIER_POINTER (name));
4126               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4127                        && current_class_ptr
4128                        && !TREE_STATIC (name))
4129                 warning ("declaration of `%s' shadows a member of `this'",
4130                         IDENTIFIER_POINTER (name));
4131               else if (oldlocal != NULL_TREE)
4132                 warning ("declaration of `%s' shadows previous local",
4133                         IDENTIFIER_POINTER (name));
4134               else if (oldglobal != NULL_TREE)
4135                 /* XXX shadow warnings in outer-more namespaces */
4136                 warning ("declaration of `%s' shadows global declaration",
4137                         IDENTIFIER_POINTER (name));
4138             }
4139         }
4140
4141       if (TREE_CODE (x) == FUNCTION_DECL)
4142         check_default_args (x);
4143
4144       /* Keep count of variables in this level with incomplete type.  */
4145       if (TREE_CODE (x) == VAR_DECL
4146           && TREE_TYPE (x) != error_mark_node
4147           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4148                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4149               /* RTTI TD entries are created while defining the type_info.  */
4150               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4151                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4152         {
4153           if (namespace_bindings_p ())
4154             namespace_scope_incomplete
4155               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4156           else
4157             current_binding_level->incomplete
4158               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4159         }
4160     }
4161
4162   if (need_new_binding)
4163     add_decl_to_level (x,
4164                        DECL_NAMESPACE_SCOPE_P (x)
4165                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4166                        : current_binding_level);
4167
4168   return x;
4169 }
4170
4171 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4172    caller to set DECL_CONTEXT properly.  */
4173
4174 static tree
4175 pushdecl_with_scope (x, level)
4176      tree x;
4177      struct binding_level *level;
4178 {
4179   register struct binding_level *b;
4180   tree function_decl = current_function_decl;
4181
4182   current_function_decl = NULL_TREE;
4183   if (level->parm_flag == 2)
4184     {
4185       b = class_binding_level;
4186       class_binding_level = level;
4187       pushdecl_class_level (x);
4188       class_binding_level = b;
4189     }
4190   else
4191     {
4192       b = current_binding_level;
4193       current_binding_level = level;
4194       x = pushdecl (x);
4195       current_binding_level = b;
4196     }
4197   current_function_decl = function_decl;
4198   return x;
4199 }
4200
4201 /* Like pushdecl, only it places X in the current namespace,
4202    if appropriate.  */
4203
4204 tree
4205 pushdecl_namespace_level (x)
4206      tree x;
4207 {
4208   register struct binding_level *b = current_binding_level;
4209   register tree t;
4210
4211   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4212
4213   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4214      what we want.  */
4215   if (TREE_CODE (x) == TYPE_DECL)
4216     {
4217       tree name = DECL_NAME (x);
4218       tree newval;
4219       tree *ptr = (tree *)0;
4220       for (; b != global_binding_level; b = b->level_chain)
4221         {
4222           tree shadowed = b->type_shadowed;
4223           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4224             if (TREE_PURPOSE (shadowed) == name)
4225               {
4226                 ptr = &TREE_VALUE (shadowed);
4227                 /* Can't break out of the loop here because sometimes
4228                    a binding level will have duplicate bindings for
4229                    PT names.  It's gross, but I haven't time to fix it.  */
4230               }
4231         }
4232       newval = TREE_TYPE (x);
4233       if (ptr == (tree *)0)
4234         {
4235           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4236              up here if this is changed to an assertion.  --KR  */
4237           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4238         }
4239       else
4240         {
4241           *ptr = newval;
4242         }
4243     }
4244   return t;
4245 }
4246
4247 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4248    if appropriate.  */
4249
4250 tree
4251 pushdecl_top_level (x)
4252      tree x;
4253 {
4254   push_to_top_level ();
4255   x = pushdecl_namespace_level (x);
4256   pop_from_top_level ();
4257   return x;
4258 }
4259
4260 /* Make the declaration of X appear in CLASS scope.  */
4261
4262 void
4263 pushdecl_class_level (x)
4264      tree x;
4265 {
4266   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4267      scope looks for the pre-mangled name.  */
4268   register tree name;
4269
4270   if (TREE_CODE (x) == OVERLOAD)
4271     x = OVL_CURRENT (x);
4272   name = DECL_NAME (x);
4273
4274   if (name)
4275     {
4276       push_class_level_binding (name, x);
4277       if (TREE_CODE (x) == TYPE_DECL)
4278         set_identifier_type_value (name, TREE_TYPE (x));
4279     }
4280   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4281     {
4282       tree f;
4283
4284       for (f = TYPE_FIELDS (TREE_TYPE (x));
4285            f;
4286            f = TREE_CHAIN (f))
4287         pushdecl_class_level (f);
4288     }
4289 }
4290
4291 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4292    DECL, or a modified version thereof.  */
4293
4294 tree
4295 maybe_push_decl (decl)
4296      tree decl;
4297 {
4298   tree type = TREE_TYPE (decl);
4299
4300   /* Add this decl to the current binding level, but not if it comes
4301      from another scope, e.g. a static member variable.  TEM may equal
4302      DECL or it may be a previous decl of the same name.  */
4303   if (decl == error_mark_node
4304       || (TREE_CODE (decl) != PARM_DECL
4305           && DECL_CONTEXT (decl) != NULL_TREE
4306           /* Definitions of namespace members outside their namespace are
4307              possible. */
4308           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4309       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4310       || TREE_CODE (type) == UNKNOWN_TYPE
4311       /* The declaration of a template specialization does not affect
4312          the functions available for overload resolution, so we do not
4313          call pushdecl.  */
4314       || (TREE_CODE (decl) == FUNCTION_DECL
4315           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4316     return decl;
4317   else
4318     return pushdecl (decl);
4319 }
4320
4321 /* Make the declaration(s) of X appear in CLASS scope
4322    under the name NAME.  */
4323
4324 void
4325 push_class_level_binding (name, x)
4326      tree name;
4327      tree x;
4328 {
4329   tree binding;
4330   /* The class_binding_level will be NULL if x is a template
4331      parameter name in a member template.  */
4332   if (!class_binding_level)
4333     return;
4334
4335   /* Make sure that this new member does not have the same name
4336      as a template parameter.  */
4337   if (TYPE_BEING_DEFINED (current_class_type))
4338     check_template_shadow (x);
4339
4340   /* If this declaration shadows a declaration from an enclosing
4341      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4342      we leave this class.  Record the shadowed declaration here.  */
4343   binding = IDENTIFIER_BINDING (name);
4344   if (binding
4345       && ((TREE_CODE (x) == OVERLOAD
4346            && BINDING_VALUE (binding)
4347            && is_overloaded_fn (BINDING_VALUE (binding)))
4348           || INHERITED_VALUE_BINDING_P (binding)))
4349     {
4350       tree shadow;
4351       tree old_decl;
4352
4353       /* If the old binding was from a base class, and was for a tag
4354          name, slide it over to make room for the new binding.  The
4355          old binding is still visible if explicitly qualified with a
4356          class-key.  */
4357       if (INHERITED_VALUE_BINDING_P (binding)
4358           && BINDING_VALUE (binding)
4359           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4360           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4361           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4362         {
4363           old_decl = BINDING_TYPE (binding);
4364           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4365           BINDING_VALUE (binding) = NULL_TREE;
4366           INHERITED_VALUE_BINDING_P (binding) = 0;
4367         }
4368       else
4369         old_decl = BINDING_VALUE (binding);
4370
4371       /* There was already a binding for X containing fewer
4372          functions than are named in X.  Find the previous
4373          declaration of X on the class-shadowed list, and update it.  */
4374       for (shadow = class_binding_level->class_shadowed;
4375            shadow;
4376            shadow = TREE_CHAIN (shadow))
4377         if (TREE_PURPOSE (shadow) == name
4378             && TREE_TYPE (shadow) == old_decl)
4379           {
4380             BINDING_VALUE (binding) = x;
4381             INHERITED_VALUE_BINDING_P (binding) = 0;
4382             TREE_TYPE (shadow) = x;
4383             return;
4384           }
4385     }
4386
4387   /* If we didn't replace an existing binding, put the binding on the
4388      stack of bindings for the identifier, and update
4389      IDENTIFIER_CLASS_VALUE.  */
4390   if (push_class_binding (name, x))
4391     {
4392       class_binding_level->class_shadowed
4393         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4394                      class_binding_level->class_shadowed);
4395       /* Record the value we are binding NAME to so that we can know
4396          what to pop later.  */
4397       TREE_TYPE (class_binding_level->class_shadowed) = x;
4398     }
4399 }
4400
4401 /* Insert another USING_DECL into the current binding level,
4402    returning this declaration. If this is a redeclaration,
4403    do nothing and return NULL_TREE.  */
4404
4405 tree
4406 push_using_decl (scope, name)
4407      tree scope;
4408      tree name;
4409 {
4410   tree decl;
4411
4412   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4413   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4414   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4415     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4416       break;
4417   if (decl)
4418     return NULL_TREE;
4419   decl = build_lang_decl (USING_DECL, name, void_type_node);
4420   DECL_INITIAL (decl) = scope;
4421   TREE_CHAIN (decl) = current_binding_level->usings;
4422   current_binding_level->usings = decl;
4423   return decl;
4424 }
4425
4426 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4427    changed (i.e. there was already a directive), or the fresh
4428    TREE_LIST otherwise.  */
4429
4430 tree
4431 push_using_directive (used)
4432      tree used;
4433 {
4434   tree ud = current_binding_level->using_directives;
4435   tree iter, ancestor;
4436
4437   /* Check if we already have this. */
4438   if (purpose_member (used, ud) != NULL_TREE)
4439     return NULL_TREE;
4440
4441   /* Recursively add all namespaces used. */
4442   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4443     push_using_directive (TREE_PURPOSE (iter));
4444
4445   ancestor = namespace_ancestor (current_decl_namespace (), used);
4446   ud = current_binding_level->using_directives;
4447   ud = tree_cons (used, ancestor, ud);
4448   current_binding_level->using_directives = ud;
4449   return ud;
4450 }
4451
4452 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4453    other definitions already in place.  We get around this by making
4454    the value of the identifier point to a list of all the things that
4455    want to be referenced by that name.  It is then up to the users of
4456    that name to decide what to do with that list.
4457
4458    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4459    slot.  It is dealt with the same way.
4460
4461    FLAGS is a bitwise-or of the following values:
4462      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4463                  namespace scope.
4464      PUSH_USING: DECL is being pushed as the result of a using
4465                  declaration.
4466
4467    The value returned may be a previous declaration if we guessed wrong
4468    about what language DECL should belong to (C or C++).  Otherwise,
4469    it's always DECL (and never something that's not a _DECL).  */
4470
4471 tree
4472 push_overloaded_decl (decl, flags)
4473      tree decl;
4474      int flags;
4475 {
4476   tree name = DECL_NAME (decl);
4477   tree old;
4478   tree new_binding;
4479   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4480
4481   if (doing_global)
4482     old = namespace_binding (name, DECL_CONTEXT (decl));
4483   else
4484     old = lookup_name_current_level (name);
4485
4486   if (old)
4487     {
4488       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4489         {
4490           tree t = TREE_TYPE (old);
4491           if (IS_AGGR_TYPE (t) && warn_shadow
4492               && (! DECL_IN_SYSTEM_HEADER (decl)
4493                   || ! DECL_IN_SYSTEM_HEADER (old)))
4494             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4495           old = NULL_TREE;
4496         }
4497       else if (is_overloaded_fn (old))
4498         {
4499           tree tmp;
4500
4501           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4502             {
4503               tree fn = OVL_CURRENT (tmp);
4504
4505               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4506                   && !(flags & PUSH_USING)
4507                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4508                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4509                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4510                           decl, fn);
4511
4512               if (duplicate_decls (decl, fn))
4513                 return fn;
4514             }
4515         }
4516       else
4517         {
4518           cp_error_at ("previous non-function declaration `%#D'", old);
4519           cp_error ("conflicts with function declaration `%#D'", decl);
4520           return decl;
4521         }
4522     }
4523
4524   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4525     {
4526       if (old && TREE_CODE (old) != OVERLOAD)
4527         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4528       else
4529         new_binding = ovl_cons (decl, old);
4530       if (flags & PUSH_USING)
4531         OVL_USED (new_binding) = 1;
4532     }
4533   else
4534     /* NAME is not ambiguous.  */
4535     new_binding = decl;
4536
4537   if (doing_global)
4538     set_namespace_binding (name, current_namespace, new_binding);
4539   else
4540     {
4541       /* We only create an OVERLOAD if there was a previous binding at
4542          this level, or if decl is a template. In the former case, we
4543          need to remove the old binding and replace it with the new
4544          binding.  We must also run through the NAMES on the binding
4545          level where the name was bound to update the chain.  */
4546
4547       if (TREE_CODE (new_binding) == OVERLOAD && old)
4548         {
4549           tree *d;
4550
4551           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4552                *d;
4553                d = &TREE_CHAIN (*d))
4554             if (*d == old
4555                 || (TREE_CODE (*d) == TREE_LIST
4556                     && TREE_VALUE (*d) == old))
4557               {
4558                 if (TREE_CODE (*d) == TREE_LIST)
4559                   /* Just replace the old binding with the new.  */
4560                   TREE_VALUE (*d) = new_binding;
4561                 else
4562                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4563                   *d = tree_cons (NULL_TREE, new_binding,
4564                                   TREE_CHAIN (*d));
4565
4566                 /* And update the CPLUS_BINDING node.  */
4567                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4568                   = new_binding;
4569                 return decl;
4570               }
4571
4572           /* We should always find a previous binding in this case.  */
4573           my_friendly_abort (0);
4574         }
4575
4576       /* Install the new binding.  */
4577       push_local_binding (name, new_binding, flags);
4578     }
4579
4580   return decl;
4581 }
4582 \f
4583 /* Generate an implicit declaration for identifier FUNCTIONID
4584    as a function of type int ().  Print a warning if appropriate.  */
4585
4586 tree
4587 implicitly_declare (functionid)
4588      tree functionid;
4589 {
4590   register tree decl;
4591
4592   /* We used to reuse an old implicit decl here,
4593      but this loses with inline functions because it can clobber
4594      the saved decl chains.  */
4595   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4596
4597   DECL_EXTERNAL (decl) = 1;
4598   TREE_PUBLIC (decl) = 1;
4599
4600   /* ISO standard says implicit declarations are in the innermost block.
4601      So we record the decl in the standard fashion.  */
4602   pushdecl (decl);
4603   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4604
4605   if (warn_implicit
4606       /* Only one warning per identifier.  */
4607       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4608     {
4609       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4610     }
4611
4612   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4613
4614   return decl;
4615 }
4616
4617 /* Return zero if the declaration NEWDECL is valid
4618    when the declaration OLDDECL (assumed to be for the same name)
4619    has already been seen.
4620    Otherwise return an error message format string with a %s
4621    where the identifier should go.  */
4622
4623 static const char *
4624 redeclaration_error_message (newdecl, olddecl)
4625      tree newdecl, olddecl;
4626 {
4627   if (TREE_CODE (newdecl) == TYPE_DECL)
4628     {
4629       /* Because C++ can put things into name space for free,
4630          constructs like "typedef struct foo { ... } foo"
4631          would look like an erroneous redeclaration.  */
4632       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4633         return 0;
4634       else
4635         return "redefinition of `%#D'";
4636     }
4637   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4638     {
4639       /* If this is a pure function, its olddecl will actually be
4640          the original initialization to `0' (which we force to call
4641          abort()).  Don't complain about redefinition in this case.  */
4642       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4643         return 0;
4644
4645       /* If both functions come from different namespaces, this is not
4646          a redeclaration - this is a conflict with a used function. */
4647       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4648           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4649         return "`%D' conflicts with used function";
4650
4651       /* We'll complain about linkage mismatches in
4652          warn_extern_redeclared_static.  */
4653
4654       /* Defining the same name twice is no good.  */
4655       if (DECL_INITIAL (olddecl) != NULL_TREE
4656           && DECL_INITIAL (newdecl) != NULL_TREE)
4657         {
4658           if (DECL_NAME (olddecl) == NULL_TREE)
4659             return "`%#D' not declared in class";
4660           else
4661             return "redefinition of `%#D'";
4662         }
4663       return 0;
4664     }
4665   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4666     {
4667       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4668            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4669            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4670           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4671               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4672               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4673         return "redefinition of `%#D'";
4674       return 0;
4675     }
4676   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4677     {
4678       /* Objects declared at top level:  */
4679       /* If at least one is a reference, it's ok.  */
4680       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4681         return 0;
4682       /* Reject two definitions.  */
4683       return "redefinition of `%#D'";
4684     }
4685   else
4686     {
4687       /* Objects declared with block scope:  */
4688       /* Reject two definitions, and reject a definition
4689          together with an external reference.  */
4690       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4691         return "redeclaration of `%#D'";
4692       return 0;
4693     }
4694 }
4695 \f
4696 /* Create a new label, named ID.  */
4697
4698 static tree
4699 make_label_decl (id, local_p)
4700      tree id;
4701      int local_p;
4702 {
4703   tree decl;
4704
4705   decl = build_decl (LABEL_DECL, id, void_type_node);
4706   if (expanding_p)
4707     /* Make sure every label has an rtx.  */
4708     label_rtx (decl);
4709
4710   DECL_CONTEXT (decl) = current_function_decl;
4711   DECL_MODE (decl) = VOIDmode;
4712   C_DECLARED_LABEL_FLAG (decl) = local_p;
4713
4714   /* Say where one reference is to the label, for the sake of the
4715      error if it is not defined.  */
4716   DECL_SOURCE_LINE (decl) = lineno;
4717   DECL_SOURCE_FILE (decl) = input_filename;
4718
4719   /* Record the fact that this identifier is bound to this label.  */
4720   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4721
4722   /* Record this label on the list of used labels so that we can check
4723      at the end of the function to see whether or not the label was
4724      actually defined.  */
4725   if ((named_label_uses == NULL || named_label_uses->label_decl != decl)
4726       && (named_label_uses == NULL
4727           || named_label_uses->names_in_scope != current_binding_level->names
4728           || named_label_uses->label_decl != decl))
4729     {
4730       struct named_label_list *new_ent;
4731       new_ent
4732         = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4733       new_ent->label_decl = decl;
4734       new_ent->names_in_scope = current_binding_level->names;
4735       new_ent->binding_level = current_binding_level;
4736       new_ent->lineno_o_goto = lineno;
4737       new_ent->filename_o_goto = input_filename;
4738       new_ent->next = named_label_uses;
4739       named_label_uses = new_ent;
4740     }
4741
4742   return decl;
4743 }
4744
4745 /* Look for a label named ID in the current function.  If one cannot
4746    be found, create one.  (We keep track of used, but undefined,
4747    labels, and complain about them at the end of a function.)  */
4748
4749 tree
4750 lookup_label (id)
4751      tree id;
4752 {
4753   tree decl;
4754
4755   /* You can't use labels at global scope.  */
4756   if (current_function_decl == NULL_TREE)
4757     {
4758       error ("label `%s' referenced outside of any function",
4759              IDENTIFIER_POINTER (id));
4760       return NULL_TREE;
4761     }
4762
4763   /* See if we've already got this label.  */
4764   decl = IDENTIFIER_LABEL_VALUE (id);
4765   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4766     return decl;
4767
4768   /* Record this label on the list of labels used in this function.
4769      We do this before calling make_label_decl so that we get the
4770      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4771   named_labels = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4772                             named_labels);
4773   /* We need a new label.  */
4774   decl = make_label_decl (id, /*local_p=*/0);
4775   /* Now fill in the information we didn't have before.  */
4776   TREE_VALUE (named_labels) = decl;
4777
4778   return decl;
4779 }
4780
4781 /* Declare a local label named ID.  */
4782
4783 tree
4784 declare_local_label (id)
4785      tree id;
4786 {
4787   tree decl;
4788
4789   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4790      this scope we can restore the old value of
4791      IDENTIFIER_TYPE_VALUE.  */
4792   current_binding_level->shadowed_labels
4793     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4794                  current_binding_level->shadowed_labels);
4795   /* Look for the label.  */
4796   decl = make_label_decl (id, /*local_p=*/1);
4797   /* Now fill in the information we didn't have before.  */
4798   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4799
4800   return decl;
4801 }
4802
4803 /* Define a label, specifying the location in the source file.
4804    Return the LABEL_DECL node for the label, if the definition is valid.
4805    Otherwise return 0.  */
4806
4807 tree
4808 define_label (filename, line, name)
4809      char *filename;
4810      int line;
4811      tree name;
4812 {
4813   tree decl = lookup_label (name);
4814
4815   /* After labels, make any new cleanups go into their
4816      own new (temporary) binding contour.  */
4817   current_binding_level->more_cleanups_ok = 0;
4818
4819   if (name == get_identifier ("wchar_t"))
4820     cp_pedwarn ("label named wchar_t");
4821
4822   if (DECL_INITIAL (decl) != NULL_TREE)
4823     {
4824       cp_error ("duplicate label `%D'", decl);
4825       return 0;
4826     }
4827   else
4828     {
4829       struct named_label_list *uses, *prev;
4830       int identified = 0;
4831       int saw_eh = 0;
4832
4833       /* Mark label as having been defined.  */
4834       DECL_INITIAL (decl) = error_mark_node;
4835       /* Say where in the source.  */
4836       DECL_SOURCE_FILE (decl) = filename;
4837       DECL_SOURCE_LINE (decl) = line;
4838
4839       prev = NULL;
4840       uses = named_label_uses;
4841       while (uses != NULL)
4842         if (uses->label_decl == decl)
4843           {
4844             struct binding_level *b = current_binding_level;
4845             while (b)
4846               {
4847                 tree new_decls = b->names;
4848                 tree old_decls = (b == uses->binding_level)
4849                                   ? uses->names_in_scope : NULL_TREE;
4850                 while (new_decls != old_decls)
4851                   {
4852                     if (TREE_CODE (new_decls) == VAR_DECL
4853                         /* Don't complain about crossing initialization
4854                            of internal entities.  They can't be accessed,
4855                            and they should be cleaned up
4856                            by the time we get to the label.  */
4857                         && ! DECL_ARTIFICIAL (new_decls)
4858                         && !(DECL_INITIAL (new_decls) == NULL_TREE
4859                              && pod_type_p (TREE_TYPE (new_decls))))
4860                       {
4861                         /* This is really only important if we're crossing
4862                            an initialization.  The POD stuff is just
4863                            pedantry; why should it matter if the class
4864                            contains a field of pointer to member type?  */
4865                         int problem = (DECL_INITIAL (new_decls)
4866                                        || (TYPE_NEEDS_CONSTRUCTING
4867                                            (TREE_TYPE (new_decls))));
4868
4869                         if (! identified)
4870                           {
4871                             if (problem)
4872                               {
4873                                 cp_error ("jump to label `%D'", decl);
4874                                 error_with_file_and_line
4875                                   (uses->filename_o_goto,
4876                                    uses->lineno_o_goto, "  from here");
4877                               }
4878                             else
4879                               {
4880                                 cp_pedwarn ("jump to label `%D'", decl);
4881                                 pedwarn_with_file_and_line
4882                                   (uses->filename_o_goto,
4883                                    uses->lineno_o_goto, "  from here");
4884                               }
4885                             identified = 1;
4886                           }
4887
4888                         if (problem)
4889                           cp_error_at ("  crosses initialization of `%#D'",
4890                                        new_decls);
4891                         else
4892                           cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4893                                          new_decls);
4894                       }
4895                     new_decls = TREE_CHAIN (new_decls);
4896                   }
4897                 if (b == uses->binding_level)
4898                   break;
4899                 if (b->eh_region && ! saw_eh)
4900                   {
4901                     if (! identified)
4902                       {
4903                         cp_error ("jump to label `%D'", decl);
4904                         error_with_file_and_line
4905                           (uses->filename_o_goto,
4906                            uses->lineno_o_goto, "  from here");
4907                         identified = 1;
4908                       }
4909                     error ("  enters exception handling block");
4910                     saw_eh = 1;
4911                   }
4912                 b = b->level_chain;
4913               }
4914
4915             if (prev != NULL)
4916               prev->next = uses->next;
4917             else
4918               named_label_uses = uses->next;
4919
4920             uses = uses->next;
4921           }
4922         else
4923           {
4924             prev = uses;
4925             uses = uses->next;
4926           }
4927       current_function_return_value = NULL_TREE;
4928       return decl;
4929     }
4930 }
4931
4932 struct cp_switch
4933 {
4934   struct binding_level *level;
4935   struct cp_switch *next;
4936 };
4937
4938 static struct cp_switch *switch_stack;
4939
4940 void
4941 push_switch ()
4942 {
4943   struct cp_switch *p
4944     = (struct cp_switch *) oballoc (sizeof (struct cp_switch));
4945   p->level = current_binding_level;
4946   p->next = switch_stack;
4947   switch_stack = p;
4948 }
4949
4950 void
4951 pop_switch ()
4952 {
4953   switch_stack = switch_stack->next;
4954 }
4955
4956 /* Note that we've seen a definition of a case label, and complain if this
4957    is a bad place for one.  */
4958
4959 void
4960 define_case_label ()
4961 {
4962   tree cleanup = last_cleanup_this_contour ();
4963   struct binding_level *b = current_binding_level;
4964   int identified = 0;
4965
4966   if (! switch_stack)
4967     /* Don't crash; we'll complain in do_case.  */
4968     return;
4969
4970   if (cleanup)
4971     {
4972       static int explained = 0;
4973       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4974       warning ("where case label appears here");
4975       if (!explained)
4976         {
4977           warning ("(enclose actions of previous case statements requiring");
4978           warning ("destructors in their own binding contours.)");
4979           explained = 1;
4980         }
4981     }
4982
4983   for (; b && b != switch_stack->level; b = b->level_chain)
4984     {
4985       tree new_decls = b->names;
4986       for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4987         {
4988           if (TREE_CODE (new_decls) == VAR_DECL
4989               /* Don't complain about crossing initialization
4990                  of internal entities.  They can't be accessed,
4991                  and they should be cleaned up
4992                  by the time we get to the label.  */
4993               && ! DECL_ARTIFICIAL (new_decls)
4994               && ((DECL_INITIAL (new_decls) != NULL_TREE
4995                    && DECL_INITIAL (new_decls) != error_mark_node)
4996                   || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4997             {
4998               if (! identified)
4999                 error ("jump to case label");
5000               identified = 1;
5001               cp_error_at ("  crosses initialization of `%#D'",
5002                            new_decls);
5003             }
5004         }
5005     }
5006
5007   /* After labels, make any new cleanups go into their
5008      own new (temporary) binding contour.  */
5009
5010   current_binding_level->more_cleanups_ok = 0;
5011   current_function_return_value = NULL_TREE;
5012 }
5013 \f
5014 /* Return the list of declarations of the current level.
5015    Note that this list is in reverse order unless/until
5016    you nreverse it; and when you do nreverse it, you must
5017    store the result back using `storedecls' or you will lose.  */
5018
5019 tree
5020 getdecls ()
5021 {
5022   return current_binding_level->names;
5023 }
5024
5025 /* Return the list of type-tags (for structs, etc) of the current level.  */
5026
5027 tree
5028 gettags ()
5029 {
5030   return current_binding_level->tags;
5031 }
5032
5033 /* Store the list of declarations of the current level.
5034    This is done for the parameter declarations of a function being defined,
5035    after they are modified in the light of any missing parameters.  */
5036
5037 static void
5038 storedecls (decls)
5039      tree decls;
5040 {
5041   current_binding_level->names = decls;
5042 }
5043
5044 /* Similarly, store the list of tags of the current level.  */
5045
5046 void
5047 storetags (tags)
5048      tree tags;
5049 {
5050   current_binding_level->tags = tags;
5051 }
5052 \f
5053 /* Given NAME, an IDENTIFIER_NODE,
5054    return the structure (or union or enum) definition for that name.
5055    Searches binding levels from BINDING_LEVEL up to the global level.
5056    If THISLEVEL_ONLY is nonzero, searches only the specified context
5057    (but skips any tag-transparent contexts to find one that is
5058    meaningful for tags).
5059    FORM says which kind of type the caller wants;
5060    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5061    If the wrong kind of type is found, and it's not a template, an error is
5062    reported.  */
5063
5064 static tree
5065 lookup_tag (form, name, binding_level, thislevel_only)
5066      enum tree_code form;
5067      tree name;
5068      struct binding_level *binding_level;
5069      int thislevel_only;
5070 {
5071   register struct binding_level *level;
5072   /* Non-zero if, we should look past a template parameter level, even
5073      if THISLEVEL_ONLY.  */
5074   int allow_template_parms_p = 1;
5075
5076   for (level = binding_level; level; level = level->level_chain)
5077     {
5078       register tree tail;
5079       if (ANON_AGGRNAME_P (name))
5080         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5081           {
5082             /* There's no need for error checking here, because
5083                anon names are unique throughout the compilation.  */
5084             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5085               return TREE_VALUE (tail);
5086           }
5087       else if (level->namespace_p)
5088         /* Do namespace lookup. */
5089         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5090           {
5091             tree old = binding_for_name (name, tail);
5092
5093             /* If we just skipped past a template parameter level,
5094                even though THISLEVEL_ONLY, and we find a template
5095                class declaration, then we use the _TYPE node for the
5096                template.  See the example below.  */
5097             if (thislevel_only && !allow_template_parms_p
5098                 && old && BINDING_VALUE (old)
5099                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5100               old = TREE_TYPE (BINDING_VALUE (old));
5101             else
5102               old = BINDING_TYPE (old);
5103
5104             /* If it has an original type, it is a typedef, and we
5105                should not return it.  */
5106             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5107               old = NULL_TREE;
5108             if (old && TREE_CODE (old) != form
5109                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5110               {
5111                 cp_error ("`%#D' redeclared as %C", old, form);
5112                 return NULL_TREE;
5113               }
5114             if (old)
5115               return old;
5116             if (thislevel_only || tail == global_namespace)
5117               return NULL_TREE;
5118           }
5119       else
5120         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5121           {
5122             if (TREE_PURPOSE (tail) == name)
5123               {
5124                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5125                 /* Should tighten this up; it'll probably permit
5126                    UNION_TYPE and a struct template, for example.  */
5127                 if (code != form
5128                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5129                   {
5130                     /* Definition isn't the kind we were looking for.  */
5131                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5132                               form);
5133                     return NULL_TREE;
5134                   }
5135                 return TREE_VALUE (tail);
5136               }
5137           }
5138       if (thislevel_only && ! level->tag_transparent)
5139         {
5140           if (level->template_parms_p && allow_template_parms_p)
5141             {
5142               /* We must deal with cases like this:
5143
5144                    template <class T> struct S;
5145                    template <class T> struct S {};
5146
5147                  When looking up `S', for the second declaration, we
5148                  would like to find the first declaration.  But, we
5149                  are in the pseudo-global level created for the
5150                  template parameters, rather than the (surrounding)
5151                  namespace level.  Thus, we keep going one more level,
5152                  even though THISLEVEL_ONLY is non-zero.  */
5153               allow_template_parms_p = 0;
5154               continue;
5155             }
5156           else
5157             return NULL_TREE;
5158         }
5159     }
5160   return NULL_TREE;
5161 }
5162
5163 #if 0
5164 void
5165 set_current_level_tags_transparency (tags_transparent)
5166      int tags_transparent;
5167 {
5168   current_binding_level->tag_transparent = tags_transparent;
5169 }
5170 #endif
5171
5172 /* Given a type, find the tag that was defined for it and return the tag name.
5173    Otherwise return 0.  However, the value can never be 0
5174    in the cases in which this is used.
5175
5176    C++: If NAME is non-zero, this is the new name to install.  This is
5177    done when replacing anonymous tags with real tag names.  */
5178
5179 static tree
5180 lookup_tag_reverse (type, name)
5181      tree type;
5182      tree name;
5183 {
5184   register struct binding_level *level;
5185
5186   for (level = current_binding_level; level; level = level->level_chain)
5187     {
5188       register tree tail;
5189       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5190         {
5191           if (TREE_VALUE (tail) == type)
5192             {
5193               if (name)
5194                 TREE_PURPOSE (tail) = name;
5195               return TREE_PURPOSE (tail);
5196             }
5197         }
5198     }
5199   return NULL_TREE;
5200 }
5201 \f
5202 /* Look up NAME in the NAMESPACE.  */
5203
5204 tree
5205 lookup_namespace_name (namespace, name)
5206      tree namespace, name;
5207 {
5208   tree val;
5209   tree template_id = NULL_TREE;
5210
5211   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5212
5213   if (TREE_CODE (name) == NAMESPACE_DECL)
5214     /* This happens for A::B<int> when B is a namespace. */
5215     return name;
5216   else if (TREE_CODE (name) == TEMPLATE_DECL)
5217     {
5218       /* This happens for A::B where B is a template, and there are no
5219          template arguments.  */
5220       cp_error ("invalid use of `%D'", name);
5221       return error_mark_node;
5222     }
5223
5224   namespace = ORIGINAL_NAMESPACE (namespace);
5225
5226   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5227     {
5228       template_id = name;
5229       name = TREE_OPERAND (name, 0);
5230       if (TREE_CODE (name) == OVERLOAD)
5231         name = DECL_NAME (OVL_CURRENT (name));
5232       else if (TREE_CODE_CLASS (TREE_CODE (name)) == 'd')
5233         name = DECL_NAME (name);
5234     }
5235
5236   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5237
5238   val = make_node (CPLUS_BINDING);
5239   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5240     return error_mark_node;
5241
5242   if (BINDING_VALUE (val))
5243     {
5244       val = BINDING_VALUE (val);
5245
5246       if (template_id)
5247         {
5248           if (DECL_CLASS_TEMPLATE_P (val))
5249             val = lookup_template_class (val,
5250                                          TREE_OPERAND (template_id, 1),
5251                                          /*in_decl=*/NULL_TREE,
5252                                          /*context=*/NULL_TREE,
5253                                          /*entering_scope=*/0);
5254           else if (DECL_FUNCTION_TEMPLATE_P (val)
5255                    || TREE_CODE (val) == OVERLOAD)
5256             val = lookup_template_function (val,
5257                                             TREE_OPERAND (template_id, 1));
5258           else
5259             {
5260               cp_error ("`%D::%D' is not a template",
5261                         namespace, name);
5262               return error_mark_node;
5263             }
5264         }
5265
5266       /* If we have a single function from a using decl, pull it out.  */
5267       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5268         val = OVL_FUNCTION (val);
5269       return val;
5270     }
5271
5272   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5273   return error_mark_node;
5274 }
5275
5276 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5277
5278 static unsigned long
5279 typename_hash (k)
5280      hash_table_key k;
5281 {
5282   unsigned long hash;
5283   tree t;
5284
5285   t = (tree) k;
5286   hash = (((unsigned long) TYPE_CONTEXT (t))
5287           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5288
5289   return hash;
5290 }
5291
5292 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5293
5294 static boolean
5295 typename_compare (k1, k2)
5296      hash_table_key k1;
5297      hash_table_key k2;
5298 {
5299   tree t1;
5300   tree t2;
5301   tree d1;
5302   tree d2;
5303
5304   t1 = (tree) k1;
5305   t2 = (tree) k2;
5306   d1 = TYPE_NAME (t1);
5307   d2 = TYPE_NAME (t2);
5308
5309   return (DECL_NAME (d1) == DECL_NAME (d2)
5310           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5311           && ((TREE_TYPE (t1) != NULL_TREE)
5312               == (TREE_TYPE (t2) != NULL_TREE))
5313           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5314           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5315 }
5316
5317 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5318    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5319    is non-NULL, this type is being created by the implicit typename
5320    extension, and BASE_TYPE is a type named `t' in some base class of
5321    `T' which depends on template parameters.
5322
5323    Returns the new TYPENAME_TYPE.  */
5324
5325 tree
5326 build_typename_type (context, name, fullname, base_type)
5327      tree context;
5328      tree name;
5329      tree fullname;
5330      tree base_type;
5331 {
5332   tree t;
5333   tree d;
5334   struct hash_entry* e;
5335
5336   static struct hash_table ht;
5337
5338   if (!ht.table)
5339     {
5340       static struct hash_table *h = &ht;
5341       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5342                             &typename_compare))
5343         fatal ("virtual memory exhausted");
5344       ggc_add_tree_hash_table_root (&h, 1);
5345     }
5346
5347   /* Build the TYPENAME_TYPE.  */
5348   t = make_aggr_type (TYPENAME_TYPE);
5349   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5350   TYPENAME_TYPE_FULLNAME (t) = fullname;
5351   TREE_TYPE (t) = base_type;
5352
5353   /* Build the corresponding TYPE_DECL.  */
5354   d = build_decl (TYPE_DECL, name, t);
5355   TYPE_NAME (TREE_TYPE (d)) = d;
5356   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5357   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5358   DECL_ARTIFICIAL (d) = 1;
5359
5360   /* See if we already have this type.  */
5361   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5362   if (e)
5363     t = (tree) e->key;
5364   else
5365     /* Insert the type into the table.  */
5366     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5367
5368   return t;
5369 }
5370
5371 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5372    unless an error occurs, in which case error_mark_node is returned.
5373    If COMPLAIN zero, don't complain about any errors that occur.  */
5374
5375 tree
5376 make_typename_type (context, name, complain)
5377      tree context, name;
5378      int complain;
5379 {
5380   tree fullname;
5381
5382   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
5383     {
5384       if (!(TYPE_LANG_SPECIFIC (name)
5385             && (CLASSTYPE_IS_TEMPLATE (name)
5386                 || CLASSTYPE_USE_TEMPLATE (name))))
5387         name = TYPE_IDENTIFIER (name);
5388       else
5389         /* Create a TEMPLATE_ID_EXPR for the type.  */
5390         name = build_nt (TEMPLATE_ID_EXPR,
5391                          CLASSTYPE_TI_TEMPLATE (name),
5392                          CLASSTYPE_TI_ARGS (name));
5393     }
5394   else if (TREE_CODE (name) == TYPE_DECL)
5395     name = DECL_NAME (name);
5396
5397   fullname = name;
5398
5399   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5400     {
5401       name = TREE_OPERAND (name, 0);
5402       if (TREE_CODE (name) == TEMPLATE_DECL)
5403         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5404     }
5405   if (TREE_CODE (name) != IDENTIFIER_NODE)
5406     my_friendly_abort (2000);
5407
5408   if (TREE_CODE (context) == NAMESPACE_DECL)
5409     {
5410       /* We can get here from typename_sub0 in the explicit_template_type
5411          expansion.  Just fail.  */
5412       if (complain)
5413         cp_error ("no class template named `%#T' in `%#T'",
5414                   name, context);
5415       return error_mark_node;
5416     }
5417
5418   if (! uses_template_parms (context)
5419       || currently_open_class (context))
5420     {
5421       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5422         {
5423           tree tmpl = NULL_TREE;
5424           if (IS_AGGR_TYPE (context))
5425             tmpl = lookup_field (context, name, 0, 0);
5426           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5427             {
5428               if (complain)
5429                 cp_error ("no class template named `%#T' in `%#T'",
5430                           name, context);
5431               return error_mark_node;
5432             }
5433
5434           return lookup_template_class (tmpl,
5435                                         TREE_OPERAND (fullname, 1),
5436                                         NULL_TREE, context,
5437                                         /*entering_scope=*/0);
5438         }
5439       else
5440         {
5441           tree t;
5442
5443           if (!IS_AGGR_TYPE (context))
5444             {
5445               if (complain)
5446                 cp_error ("no type named `%#T' in `%#T'", name, context);
5447               return error_mark_node;
5448             }
5449
5450           t = lookup_field (context, name, 0, 1);
5451           if (t)
5452             return TREE_TYPE (t);
5453         }
5454     }
5455
5456   /* If the CONTEXT is not a template type, then either the field is
5457      there now or its never going to be.  */
5458   if (!uses_template_parms (context))
5459     {
5460       if (complain)
5461         cp_error ("no type named `%#T' in `%#T'", name, context);
5462       return error_mark_node;
5463     }
5464
5465
5466   return build_typename_type (context, name, fullname,  NULL_TREE);
5467 }
5468
5469 /* Select the right _DECL from multiple choices. */
5470
5471 static tree
5472 select_decl (binding, flags)
5473      tree binding;
5474      int flags;
5475 {
5476   tree val;
5477   val = BINDING_VALUE (binding);
5478   if (LOOKUP_NAMESPACES_ONLY (flags))
5479     {
5480       /* We are not interested in types. */
5481       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5482         return val;
5483       return NULL_TREE;
5484     }
5485
5486   /* If we could have a type and
5487      we have nothing or we need a type and have none.  */
5488   if (BINDING_TYPE (binding)
5489       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5490                    && TREE_CODE (val) != TYPE_DECL)))
5491     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5492   /* Don't return non-types if we really prefer types. */
5493   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5494            && (TREE_CODE (val) != TEMPLATE_DECL
5495                || !DECL_CLASS_TEMPLATE_P (val)))
5496     val = NULL_TREE;
5497
5498   return val;
5499 }
5500
5501 /* Unscoped lookup of a global: iterate over current namespaces,
5502    considering using-directives.  If SPACESP is non-NULL, store a list
5503    of the namespaces we've considered in it.  */
5504
5505 tree
5506 unqualified_namespace_lookup (name, flags, spacesp)
5507      tree name;
5508      int flags;
5509      tree *spacesp;
5510 {
5511   tree b = make_node (CPLUS_BINDING);
5512   tree initial = current_decl_namespace();
5513   tree scope = initial;
5514   tree siter;
5515   struct binding_level *level;
5516   tree val = NULL_TREE;
5517
5518   if (spacesp)
5519     *spacesp = NULL_TREE;
5520
5521   for (; !val; scope = CP_DECL_CONTEXT (scope))
5522     {
5523       if (spacesp)
5524         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5525       val = binding_for_name (name, scope);
5526
5527       /* Initialize binding for this context. */
5528       BINDING_VALUE (b) = BINDING_VALUE (val);
5529       BINDING_TYPE (b) = BINDING_TYPE (val);
5530
5531       /* Add all _DECLs seen through local using-directives. */
5532       for (level = current_binding_level;
5533            !level->namespace_p;
5534            level = level->level_chain)
5535         if (!lookup_using_namespace (name, b, level->using_directives,
5536                                      scope, flags, spacesp))
5537           /* Give up because of error. */
5538           return error_mark_node;
5539
5540       /* Add all _DECLs seen through global using-directives. */
5541       /* XXX local and global using lists should work equally. */
5542       siter = initial;
5543       while (1)
5544         {
5545           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5546                                        scope, flags, spacesp))
5547             /* Give up because of error. */
5548             return error_mark_node;
5549           if (siter == scope) break;
5550           siter = CP_DECL_CONTEXT (siter);
5551         }
5552
5553       val = select_decl (b, flags);
5554       if (scope == global_namespace)
5555         break;
5556     }
5557   return val;
5558 }
5559
5560 /* Combine prefer_type and namespaces_only into flags.  */
5561
5562 static int
5563 lookup_flags (prefer_type, namespaces_only)
5564   int prefer_type, namespaces_only;
5565 {
5566   if (namespaces_only)
5567     return LOOKUP_PREFER_NAMESPACES;
5568   if (prefer_type > 1)
5569     return LOOKUP_PREFER_TYPES;
5570   if (prefer_type > 0)
5571     return LOOKUP_PREFER_BOTH;
5572   return 0;
5573 }
5574
5575 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5576    ignore it or not.  Subroutine of lookup_name_real.  */
5577
5578 static tree
5579 qualify_lookup (val, flags)
5580      tree val;
5581      int flags;
5582 {
5583   if (val == NULL_TREE)
5584     return val;
5585   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5586     return val;
5587   if ((flags & LOOKUP_PREFER_TYPES)
5588       && (TREE_CODE (val) == TYPE_DECL
5589           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5590               && DECL_CLASS_TEMPLATE_P (val))))
5591     return val;
5592   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5593     return NULL_TREE;
5594   return val;
5595 }
5596
5597 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5598    that.  */
5599
5600 static void
5601 warn_about_implicit_typename_lookup (typename, binding)
5602      tree typename;
5603      tree binding;
5604 {
5605   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5606   tree name = DECL_NAME (typename);
5607
5608   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5609          && CLASSTYPE_TEMPLATE_INFO (subtype)
5610          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5611       && ! (TREE_CODE (binding) == TYPE_DECL
5612             && same_type_p (TREE_TYPE (binding), subtype)))
5613     {
5614       cp_warning ("lookup of `%D' finds `%#D'",
5615                   name, binding);
5616       cp_warning ("  instead of `%D' from dependent base class",
5617                   typename);
5618       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5619                   constructor_name (current_class_type), name);
5620     }
5621 }
5622
5623 /* Look up NAME in the current binding level and its superiors in the
5624    namespace of variables, functions and typedefs.  Return a ..._DECL
5625    node of some kind representing its definition if there is only one
5626    such declaration, or return a TREE_LIST with all the overloaded
5627    definitions if there are many, or return 0 if it is undefined.
5628
5629    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5630    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5631    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5632    Otherwise we prefer non-TYPE_DECLs.
5633
5634    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5635    using IDENTIFIER_CLASS_VALUE.  */
5636
5637 static tree
5638 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5639      tree name;
5640      int prefer_type, nonclass, namespaces_only;
5641 {
5642   tree t;
5643   tree val = NULL_TREE;
5644   int yylex = 0;
5645   tree from_obj = NULL_TREE;
5646   int flags;
5647   int val_is_implicit_typename = 0;
5648
5649   /* Hack: copy flag set by parser, if set. */
5650   if (only_namespace_names)
5651     namespaces_only = 1;
5652
5653   if (prefer_type == -2)
5654     {
5655       extern int looking_for_typename;
5656       tree type = NULL_TREE;
5657
5658       yylex = 1;
5659       prefer_type = looking_for_typename;
5660
5661       flags = lookup_flags (prefer_type, namespaces_only);
5662       /* If the next thing is '<', class templates are types. */
5663       if (looking_for_template)
5664         flags |= LOOKUP_TEMPLATES_EXPECTED;
5665
5666       /* std:: becomes :: for now.  */
5667       if (got_scope == std_node)
5668         got_scope = void_type_node;
5669
5670       if (got_scope)
5671         type = got_scope;
5672       else if (got_object != error_mark_node)
5673         type = got_object;
5674
5675       if (type)
5676         {
5677           if (type == error_mark_node)
5678             return error_mark_node;
5679           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5680             type = TREE_TYPE (type);
5681
5682           if (TYPE_P (type))
5683             type = complete_type (type);
5684
5685           if (TREE_CODE (type) == VOID_TYPE)
5686             type = global_namespace;
5687           if (TREE_CODE (type) == NAMESPACE_DECL)
5688             {
5689               val = make_node (CPLUS_BINDING);
5690               flags |= LOOKUP_COMPLAIN;
5691               if (!qualified_lookup_using_namespace (name, type, val, flags))
5692                 return NULL_TREE;
5693               val = select_decl (val, flags);
5694             }
5695           else if (! IS_AGGR_TYPE (type)
5696                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5697                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5698                    || TREE_CODE (type) == TYPENAME_TYPE)
5699             /* Someone else will give an error about this if needed.  */
5700             val = NULL_TREE;
5701           else if (type == current_class_type)
5702             val = IDENTIFIER_CLASS_VALUE (name);
5703           else
5704             {
5705               val = lookup_member (type, name, 0, prefer_type);
5706               type_access_control (type, val);
5707             }
5708         }
5709       else
5710         val = NULL_TREE;
5711
5712       if (got_scope)
5713         goto done;
5714       else if (got_object && val)
5715         from_obj = val;
5716     }
5717   else
5718     {
5719       flags = lookup_flags (prefer_type, namespaces_only);
5720       /* If we're not parsing, we need to complain. */
5721       flags |= LOOKUP_COMPLAIN;
5722     }
5723
5724   /* First, look in non-namespace scopes.  */
5725
5726   if (current_class_type == NULL_TREE)
5727     nonclass = 1;
5728
5729   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5730     {
5731       tree binding;
5732
5733       if (!LOCAL_BINDING_P (t) && nonclass)
5734         /* We're not looking for class-scoped bindings, so keep going.  */
5735         continue;
5736
5737       /* If this is the kind of thing we're looking for, we're done.  */
5738       if (qualify_lookup (BINDING_VALUE (t), flags))
5739         binding = BINDING_VALUE (t);
5740       else if ((flags & LOOKUP_PREFER_TYPES)
5741                && qualify_lookup (BINDING_TYPE (t), flags))
5742         binding = BINDING_TYPE (t);
5743       else
5744         binding = NULL_TREE;
5745
5746       /* Handle access control on types from enclosing or base classes.  */
5747       if (binding && ! yylex
5748           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5749         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5750
5751       if (binding
5752           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5753         {
5754           if (val_is_implicit_typename && !yylex)
5755             warn_about_implicit_typename_lookup (val, binding);
5756           val = binding;
5757           val_is_implicit_typename
5758             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5759           if (!val_is_implicit_typename)
5760             break;
5761         }
5762     }
5763
5764   /* Now lookup in namespace scopes.  */
5765   if (!val || val_is_implicit_typename)
5766     {
5767       t = unqualified_namespace_lookup (name, flags, 0);
5768       if (t)
5769         {
5770           if (val_is_implicit_typename && !yylex)
5771             warn_about_implicit_typename_lookup (val, t);
5772           val = t;
5773         }
5774     }
5775
5776  done:
5777   if (val)
5778     {
5779       /* This should only warn about types used in qualified-ids.  */
5780       if (from_obj && from_obj != val)
5781         {
5782           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5783               && TREE_CODE (val) == TYPE_DECL
5784               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5785             {
5786               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5787                           name, got_object, TREE_TYPE (from_obj));
5788               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5789                           TREE_TYPE (val));
5790             }
5791
5792           /* We don't change val to from_obj if got_object depends on
5793              template parms because that breaks implicit typename for
5794              destructor calls.  */
5795           if (! uses_template_parms (got_object))
5796             val = from_obj;
5797         }
5798
5799       /* If we have a single function from a using decl, pull it out.  */
5800       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5801         val = OVL_FUNCTION (val);
5802     }
5803   else if (from_obj)
5804     val = from_obj;
5805
5806   return val;
5807 }
5808
5809 tree
5810 lookup_name_nonclass (name)
5811      tree name;
5812 {
5813   return lookup_name_real (name, 0, 1, 0);
5814 }
5815
5816 tree
5817 lookup_function_nonclass (name, args)
5818      tree name;
5819      tree args;
5820 {
5821   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5822 }
5823
5824 tree
5825 lookup_name_namespace_only (name)
5826      tree name;
5827 {
5828   /* type-or-namespace, nonclass, namespace_only */
5829   return lookup_name_real (name, 1, 1, 1);
5830 }
5831
5832 tree
5833 lookup_name (name, prefer_type)
5834      tree name;
5835      int prefer_type;
5836 {
5837   return lookup_name_real (name, prefer_type, 0, 0);
5838 }
5839
5840 /* Similar to `lookup_name' but look only in the innermost non-class
5841    binding level.  */
5842
5843 tree
5844 lookup_name_current_level (name)
5845      tree name;
5846 {
5847   struct binding_level *b;
5848   tree t = NULL_TREE;
5849
5850   b = current_binding_level;
5851   while (b->parm_flag == 2)
5852     b = b->level_chain;
5853
5854   if (b->namespace_p)
5855     {
5856       t = IDENTIFIER_NAMESPACE_VALUE (name);
5857
5858       /* extern "C" function() */
5859       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5860         t = TREE_VALUE (t);
5861     }
5862   else if (IDENTIFIER_BINDING (name)
5863            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
5864     {
5865       while (1)
5866         {
5867           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
5868             return IDENTIFIER_VALUE (name);
5869
5870           if (b->keep == 2)
5871             b = b->level_chain;
5872           else
5873             break;
5874         }
5875     }
5876
5877   return t;
5878 }
5879
5880 /* Like lookup_name_current_level, but for types.  */
5881
5882 tree
5883 lookup_type_current_level (name)
5884      tree name;
5885 {
5886   register tree t = NULL_TREE;
5887
5888   my_friendly_assert (! current_binding_level->namespace_p, 980716);
5889
5890   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5891       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5892     {
5893       struct binding_level *b = current_binding_level;
5894       while (1)
5895         {
5896           if (purpose_member (name, b->type_shadowed))
5897             return REAL_IDENTIFIER_TYPE_VALUE (name);
5898           if (b->keep == 2)
5899             b = b->level_chain;
5900           else
5901             break;
5902         }
5903     }
5904
5905   return t;
5906 }
5907
5908 void
5909 begin_only_namespace_names ()
5910 {
5911   only_namespace_names = 1;
5912 }
5913
5914 void
5915 end_only_namespace_names ()
5916 {
5917   only_namespace_names = 0;
5918 }
5919 \f
5920 /* Arrange for the user to get a source line number, even when the
5921    compiler is going down in flames, so that she at least has a
5922    chance of working around problems in the compiler.  We used to
5923    call error(), but that let the segmentation fault continue
5924    through; now, it's much more passive by asking them to send the
5925    maintainers mail about the problem.  */
5926
5927 static void
5928 signal_catch (sig)
5929      int sig ATTRIBUTE_UNUSED;
5930 {
5931   signal (SIGSEGV, SIG_DFL);
5932 #ifdef SIGIOT
5933   signal (SIGIOT, SIG_DFL);
5934 #endif
5935 #ifdef SIGILL
5936   signal (SIGILL, SIG_DFL);
5937 #endif
5938 #ifdef SIGABRT
5939   signal (SIGABRT, SIG_DFL);
5940 #endif
5941 #ifdef SIGBUS
5942   signal (SIGBUS, SIG_DFL);
5943 #endif
5944   my_friendly_abort (0);
5945 }
5946
5947 /* Push the declarations of builtin types into the namespace.
5948    RID_INDEX, if < RID_MAX is the index of the builtin type
5949    in the array RID_POINTERS.  NAME is the name used when looking
5950    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
5951
5952 static void
5953 record_builtin_type (rid_index, name, type)
5954      enum rid rid_index;
5955      const char *name;
5956      tree type;
5957 {
5958   tree rname = NULL_TREE, tname = NULL_TREE;
5959   tree tdecl = NULL_TREE;
5960
5961   if ((int) rid_index < (int) RID_MAX)
5962     rname = ridpointers[(int) rid_index];
5963   if (name)
5964     tname = get_identifier (name);
5965
5966   TYPE_BUILT_IN (type) = 1;
5967
5968   if (tname)
5969     {
5970       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5971       set_identifier_type_value (tname, NULL_TREE);
5972       if ((int) rid_index < (int) RID_MAX)
5973         /* Built-in types live in the global namespace. */
5974         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5975     }
5976   if (rname != NULL_TREE)
5977     {
5978       if (tname != NULL_TREE)
5979         {
5980           set_identifier_type_value (rname, NULL_TREE);
5981           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5982         }
5983       else
5984         {
5985           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5986           set_identifier_type_value (rname, NULL_TREE);
5987         }
5988     }
5989 }
5990
5991 /* Record one of the standard Java types.
5992  * Declare it as having the given NAME.
5993  * If SIZE > 0, it is the size of one of the integral types;
5994  * otherwise it is the negative of the size of one of the other types.  */
5995
5996 static tree
5997 record_builtin_java_type (name, size)
5998      const char *name;
5999      int size;
6000 {
6001   tree type, decl;
6002   if (size > 0)
6003     type = make_signed_type (size);
6004   else if (size > -32)
6005     { /* "__java_char" or ""__java_boolean". */
6006       type = make_unsigned_type (-size);
6007       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6008     }
6009   else
6010     { /* "__java_float" or ""__java_double". */
6011       type = make_node (REAL_TYPE);
6012       TYPE_PRECISION (type) = - size;
6013       layout_type (type);
6014     }
6015   record_builtin_type (RID_MAX, name, type);
6016   decl = TYPE_NAME (type);
6017
6018   /* Suppress generate debug symbol entries for these types,
6019      since for normal C++ they are just clutter.
6020      However, push_lang_context undoes this if extern "Java" is seen. */
6021   DECL_IGNORED_P (decl) = 1;
6022
6023   TYPE_FOR_JAVA (type) = 1;
6024   return type;
6025 }
6026
6027 /* Push a type into the namespace so that the back-ends ignore it. */
6028
6029 static void
6030 record_unknown_type (type, name)
6031      tree type;
6032      const char *name;
6033 {
6034   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6035   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6036   DECL_IGNORED_P (decl) = 1;
6037   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6038   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6039   TYPE_ALIGN (type) = 1;
6040   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6041 }
6042
6043 /* Create the predefined scalar types of C,
6044    and some nodes representing standard constants (0, 1, (void *)0).
6045    Initialize the global binding level.
6046    Make definitions for built-in primitive functions.  */
6047
6048 void
6049 init_decl_processing ()
6050 {
6051   tree fields[20];
6052   int wchar_type_size;
6053   tree array_domain_type;
6054
6055   /* Check to see that the user did not specify an invalid combination
6056      of command-line options.  */
6057   if (flag_new_abi && !flag_vtable_thunks)
6058     fatal ("the new ABI requires vtable thunks");
6059
6060   /* Have to make these distinct before we try using them.  */
6061   lang_name_cplusplus = get_identifier ("C++");
6062   lang_name_c = get_identifier ("C");
6063   lang_name_java = get_identifier ("Java");
6064
6065   /* Let the back-end now how to save and restore language-specific
6066      per-function globals.  */
6067   init_lang_status = &push_cp_function_context;
6068   free_lang_status = &pop_cp_function_context;
6069   mark_lang_status = &mark_cp_function_context;
6070
6071   cp_parse_init ();
6072   init_decl2 ();
6073   init_pt ();
6074
6075   /* Create the global variables.  */
6076   push_to_top_level ();
6077
6078   /* Enter the global namespace. */
6079   my_friendly_assert (global_namespace == NULL_TREE, 375);
6080   push_namespace (get_identifier ("::"));
6081   global_namespace = current_namespace;
6082   current_lang_name = NULL_TREE;
6083
6084   /* Adjust various flags based on command-line settings.  */
6085   if (flag_strict_prototype == 2)
6086     flag_strict_prototype = pedantic;
6087   if (! flag_permissive && ! pedantic)
6088     flag_pedantic_errors = 1;
6089   if (!flag_no_inline)
6090     flag_inline_trees = 1;
6091
6092   strict_prototypes_lang_c = flag_strict_prototype;
6093
6094   /* Initially, C.  */
6095   current_lang_name = lang_name_c;
6096
6097   current_function_decl = NULL_TREE;
6098   current_binding_level = NULL_BINDING_LEVEL;
6099   free_binding_level = NULL_BINDING_LEVEL;
6100
6101   /* Because most segmentation signals can be traced back into user
6102      code, catch them and at least give the user a chance of working
6103      around compiler bugs.  */
6104   signal (SIGSEGV, signal_catch);
6105
6106   /* We will also catch aborts in the back-end through signal_catch and
6107      give the user a chance to see where the error might be, and to defeat
6108      aborts in the back-end when there have been errors previously in their
6109      code.  */
6110 #ifdef SIGIOT
6111   signal (SIGIOT, signal_catch);
6112 #endif
6113 #ifdef SIGILL
6114   signal (SIGILL, signal_catch);
6115 #endif
6116 #ifdef SIGABRT
6117   signal (SIGABRT, signal_catch);
6118 #endif
6119 #ifdef SIGBUS
6120   signal (SIGBUS, signal_catch);
6121 #endif
6122
6123   build_common_tree_nodes (flag_signed_char);
6124
6125   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6126   TREE_TYPE (error_mark_list) = error_mark_node;
6127
6128   /* Make the binding_level structure for global names.  */
6129   pushlevel (0);
6130   global_binding_level = current_binding_level;
6131   /* The global level is the namespace level of ::.  */
6132   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6133   declare_namespace_level ();
6134
6135   this_identifier = get_identifier (THIS_NAME);
6136   in_charge_identifier = get_identifier (IN_CHARGE_NAME);
6137   ctor_identifier = get_identifier (CTOR_NAME);
6138   dtor_identifier = get_identifier (DTOR_NAME);
6139   pfn_identifier = get_identifier (VTABLE_PFN_NAME);
6140   index_identifier = get_identifier (VTABLE_INDEX_NAME);
6141   delta_identifier = get_identifier (VTABLE_DELTA_NAME);
6142   delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
6143   pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
6144
6145   /* Define `int' and `char' first so that dbx will output them first.  */
6146   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6147   record_builtin_type (RID_CHAR, "char", char_type_node);
6148
6149   /* `signed' is the same as `int' */
6150   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6151   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6152   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6153   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6154   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6155   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6156   record_builtin_type (RID_MAX, "long long unsigned int",
6157                        long_long_unsigned_type_node);
6158   record_builtin_type (RID_MAX, "long long unsigned",
6159                        long_long_unsigned_type_node);
6160   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6161   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6162   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6163
6164   ptrdiff_type_node
6165     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6166
6167   /* Define both `signed char' and `unsigned char'.  */
6168   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6169   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6170
6171   /* `unsigned long' is the standard type for sizeof.
6172      Note that stddef.h uses `unsigned long',
6173      and this must agree, even if long and int are the same size.  */
6174   set_sizetype
6175     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6176
6177   /* Create the widest literal types. */
6178   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6179   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6180                         widest_integer_literal_type_node));
6181
6182   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6183   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6184                         widest_unsigned_literal_type_node));
6185
6186   /* These are types that type_for_size and type_for_mode use.  */
6187   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6188   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6189   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6190   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6191 #if HOST_BITS_PER_WIDE_INT >= 64
6192   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6193 #endif
6194   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6195   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6196   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6197   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6198 #if HOST_BITS_PER_WIDE_INT >= 64
6199   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6200 #endif
6201
6202   build_common_tree_nodes_2 (flag_short_double);
6203
6204   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6205   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6206   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6207   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6208   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6209   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6210   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6211   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6212
6213   integer_two_node = build_int_2 (2, 0);
6214   TREE_TYPE (integer_two_node) = integer_type_node;
6215   integer_three_node = build_int_2 (3, 0);
6216   TREE_TYPE (integer_three_node) = integer_type_node;
6217
6218   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6219   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6220   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6221   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6222   TYPE_PRECISION (boolean_type_node) = 1;
6223   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6224   boolean_false_node = build_int_2 (0, 0);
6225   TREE_TYPE (boolean_false_node) = boolean_type_node;
6226   boolean_true_node = build_int_2 (1, 0);
6227   TREE_TYPE (boolean_true_node) = boolean_type_node;
6228
6229   signed_size_zero_node = build_int_2 (0, 0);
6230   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6231   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6232   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6233
6234   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6235                         complex_integer_type_node));
6236   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6237                         complex_float_type_node));
6238   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6239                         complex_double_type_node));
6240   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6241                         complex_long_double_type_node));
6242
6243   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6244
6245   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6246   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6247   TREE_PARMLIST (void_list_node) = 1;
6248
6249   /* Used for expressions that do nothing, but are not errors.  */
6250   void_zero_node = build_int_2 (0, 0);
6251   TREE_TYPE (void_zero_node) = void_type_node;
6252
6253   string_type_node = build_pointer_type (char_type_node);
6254   const_string_type_node
6255     = build_pointer_type (build_qualified_type (char_type_node,
6256                                                 TYPE_QUAL_CONST));
6257   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6258 #if 0
6259   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6260 #endif
6261
6262   /* Make a type to be the domain of a few array types
6263      whose domains don't really matter.
6264      200 is small enough that it always fits in size_t.  */
6265   array_domain_type = build_index_type (build_int_2 (200, 0));
6266
6267   /* Make a type for arrays of characters.
6268      With luck nothing will ever really depend on the length of this
6269      array type.  */
6270   char_array_type_node
6271     = build_array_type (char_type_node, array_domain_type);
6272   /* Likewise for arrays of ints.  */
6273   int_array_type_node
6274     = build_array_type (integer_type_node, array_domain_type);
6275
6276   if (flag_new_abi)
6277     delta_type_node = ptrdiff_type_node;
6278   else if (flag_huge_objects)
6279     delta_type_node = long_integer_type_node;
6280   else
6281     delta_type_node = short_integer_type_node;
6282
6283   if (flag_new_abi)
6284     vtable_index_type = ptrdiff_type_node;
6285   else
6286     vtable_index_type = delta_type_node;
6287
6288   default_function_type
6289     = build_function_type (integer_type_node, NULL_TREE);
6290
6291   ptr_type_node = build_pointer_type (void_type_node);
6292   const_ptr_type_node
6293     = build_pointer_type (build_qualified_type (void_type_node,
6294                                                 TYPE_QUAL_CONST));
6295   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6296   lang_type_promotes_to = convert_type_from_ellipsis;
6297
6298   void_ftype_ptr
6299     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6300
6301   /* C++ extensions */
6302
6303   unknown_type_node = make_node (UNKNOWN_TYPE);
6304   record_unknown_type (unknown_type_node, "unknown type");
6305
6306   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6307   TREE_TYPE (unknown_type_node) = unknown_type_node;
6308
6309   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6310
6311   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6312      result.  */
6313   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6314   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6315
6316   /* This is special for C++ so functions can be overloaded.  */
6317   wchar_type_node = get_identifier (flag_short_wchar
6318                                     ? "short unsigned int"
6319                                     : WCHAR_TYPE);
6320   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6321   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6322   signed_wchar_type_node = make_signed_type (wchar_type_size);
6323   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6324   wchar_type_node
6325     = TREE_UNSIGNED (wchar_type_node)
6326       ? unsigned_wchar_type_node
6327       : signed_wchar_type_node;
6328   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6329
6330   /* Artificial declaration of wchar_t -- can be bashed */
6331   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6332                                 wchar_type_node);
6333   pushdecl (wchar_decl_node);
6334
6335   /* This is for wide string constants.  */
6336   wchar_array_type_node
6337     = build_array_type (wchar_type_node, array_domain_type);
6338
6339   if (flag_vtable_thunks)
6340     {
6341       /* Make sure we get a unique function type, so we can give
6342          its pointer type a name.  (This wins for gdb.) */
6343       tree vfunc_type = make_node (FUNCTION_TYPE);
6344       TREE_TYPE (vfunc_type) = integer_type_node;
6345       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6346       layout_type (vfunc_type);
6347
6348       vtable_entry_type = build_pointer_type (vfunc_type);
6349     }
6350   else
6351     {
6352       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6353       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
6354                                    delta_type_node);
6355       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
6356                                    delta_type_node);
6357       fields[2] = build_lang_decl (FIELD_DECL, pfn_identifier,
6358                                    ptr_type_node);
6359       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6360                            double_type_node);
6361
6362       /* Make this part of an invisible union.  */
6363       fields[3] = copy_node (fields[2]);
6364       TREE_TYPE (fields[3]) = delta_type_node;
6365       DECL_NAME (fields[3]) = delta2_identifier;
6366       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6367       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6368       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6369       TREE_UNSIGNED (fields[3]) = 0;
6370       TREE_CHAIN (fields[2]) = fields[3];
6371       vtable_entry_type = build_qualified_type (vtable_entry_type,
6372                                                 TYPE_QUAL_CONST);
6373     }
6374   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6375
6376   vtbl_type_node
6377     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6378   layout_type (vtbl_type_node);
6379   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6380   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6381   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6382   layout_type (vtbl_ptr_type_node);
6383   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6384
6385   std_node = build_decl (NAMESPACE_DECL,
6386                          get_identifier (flag_honor_std ? "fake std":"std"),
6387                          void_type_node);
6388   pushdecl (std_node);
6389
6390   if (flag_new_abi)
6391     {
6392       push_namespace (get_identifier ("__cxxabiv1"));
6393       abi_node = current_namespace;
6394       pop_namespace ();
6395     }
6396
6397   global_type_node = make_node (LANG_TYPE);
6398   record_unknown_type (global_type_node, "global type");
6399
6400   /* Now, C++.  */
6401   current_lang_name = lang_name_cplusplus;
6402
6403   {
6404     tree bad_alloc_type_node, newtype, deltype;
6405     if (flag_honor_std)
6406       push_namespace (get_identifier ("std"));
6407     bad_alloc_type_node = xref_tag
6408       (class_type_node, get_identifier ("bad_alloc"), 1);
6409     if (flag_honor_std)
6410       pop_namespace ();
6411     newtype = build_exception_variant
6412       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6413     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6414     push_cp_library_fn (ansi_opname[(int) NEW_EXPR], newtype);
6415     push_cp_library_fn (ansi_opname[(int) VEC_NEW_EXPR], newtype);
6416     global_delete_fndecl = push_cp_library_fn (ansi_opname[(int) DELETE_EXPR],
6417                                                deltype);
6418     push_cp_library_fn (ansi_opname[(int) VEC_DELETE_EXPR], deltype);
6419   }
6420
6421   abort_fndecl
6422     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6423
6424   /* Perform other language dependent initializations.  */
6425   init_class_processing ();
6426   init_init_processing ();
6427   init_search_processing ();
6428   init_rtti_processing ();
6429
6430   if (flag_exceptions)
6431     init_exception_processing ();
6432   if (flag_no_inline)
6433     {
6434       flag_inline_functions = 0;
6435     }
6436
6437   if (! supports_one_only ())
6438     flag_weak = 0;
6439
6440   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6441   make_fname_decl = cp_make_fname_decl;
6442   declare_function_name ();
6443
6444   /* Prepare to check format strings against argument lists.  */
6445   init_function_format_info ();
6446
6447   /* Show we use EH for cleanups.  */
6448   using_eh_for_cleanups ();
6449
6450   print_error_function = lang_print_error_function;
6451   lang_get_alias_set = &c_get_alias_set;
6452   valid_lang_attribute = cp_valid_lang_attribute;
6453
6454   /* Maintain consistency.  Perhaps we should just complain if they
6455      say -fwritable-strings?  */
6456   if (flag_writable_strings)
6457     flag_const_strings = 0;
6458
6459   /* Add GC roots for all of our global variables.  */
6460   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6461   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6462   ggc_add_tree_root (&integer_three_node, 1);
6463   ggc_add_tree_root (&integer_two_node, 1);
6464   ggc_add_tree_root (&signed_size_zero_node, 1);
6465   ggc_add_tree_root (&size_one_node, 1);
6466   ggc_add_tree_root (&size_zero_node, 1);
6467   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6468                 mark_binding_level);
6469   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6470   ggc_add_tree_root (&static_ctors, 1);
6471   ggc_add_tree_root (&static_dtors, 1);
6472   ggc_add_tree_root (&lastiddecl, 1);
6473
6474   ggc_add_tree_root (&last_function_parm_tags, 1);
6475   ggc_add_tree_root (&current_function_return_value, 1);
6476   ggc_add_tree_root (&current_function_parms, 1);
6477   ggc_add_tree_root (&current_function_parm_tags, 1);
6478   ggc_add_tree_root (&last_function_parms, 1);
6479   ggc_add_tree_root (&error_mark_list, 1);
6480
6481   ggc_add_tree_root (&global_namespace, 1);
6482   ggc_add_tree_root (&global_type_node, 1);
6483   ggc_add_tree_root (&anonymous_namespace_name, 1);
6484
6485   ggc_add_tree_root (&got_object, 1);
6486   ggc_add_tree_root (&got_scope, 1);
6487
6488   ggc_add_tree_root (&current_lang_name, 1);
6489   ggc_add_tree_root (&static_aggregates, 1);
6490 }
6491
6492 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6493    decl, NAME is the initialization string and TYPE_DEP indicates whether
6494    NAME depended on the type of the function. We make use of that to detect
6495    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6496    the function before emitting any of it, we don't need to treat the
6497    VAR_DECL specially. We can decide whether to emit it later, if it was
6498    used.  */
6499
6500 static tree
6501 cp_make_fname_decl (id, name, type_dep)
6502      tree id;
6503      const char *name;
6504      int type_dep;
6505 {
6506   tree decl, type, init;
6507   size_t length = strlen (name);
6508   tree domain = NULL_TREE;
6509
6510   if (!processing_template_decl)
6511     type_dep = 0;
6512   if (!type_dep)
6513     domain = build_index_type (build_int_2 (length, 0));
6514
6515   type =  build_cplus_array_type
6516           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6517            domain);
6518
6519   decl = build_lang_decl (VAR_DECL, id, type);
6520   TREE_STATIC (decl) = 1;
6521   TREE_READONLY (decl) = 1;
6522   DECL_SOURCE_LINE (decl) = 0;
6523   DECL_ARTIFICIAL (decl) = 1;
6524   DECL_IN_SYSTEM_HEADER (decl) = 1;
6525   pushdecl (decl);
6526   if (processing_template_decl)
6527     decl = push_template_decl (decl);
6528   if (type_dep)
6529     {
6530       init = build (FUNCTION_NAME, type);
6531       DECL_PRETTY_FUNCTION_P (decl) = 1;
6532     }
6533   else
6534     {
6535       init = build_string (length + 1, name);
6536       TREE_TYPE (init) = type;
6537     }
6538   DECL_INITIAL (decl) = init;
6539   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6540
6541   /* We will have to make sure we only emit this, if it is actually used. */
6542   return decl;
6543 }
6544
6545 /* Function to print any language-specific context for an error message.  */
6546
6547 static void
6548 lang_print_error_function (file)
6549      const char *file;
6550 {
6551   default_print_error_function (file);
6552   maybe_print_template_context ();
6553 }
6554
6555 /* Entry point for the benefit of c_common_nodes_and_builtins.
6556
6557    Make a definition for a builtin function named NAME and whose data type
6558    is TYPE.  TYPE should be a function type with argument types.
6559
6560    CLASS and CODE tell later passes how to compile calls to this function.
6561    See tree.h for possible values.
6562
6563    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6564    the name to be called if we can't opencode the function.  */
6565
6566 tree
6567 builtin_function (name, type, code, class, libname)
6568      const char *name;
6569      tree type;
6570      int code;
6571      enum built_in_class class;
6572      const char *libname;
6573 {
6574   tree decl = build_library_fn_1 (get_identifier (name), type);
6575   DECL_BUILT_IN_CLASS (decl) = class;
6576   DECL_FUNCTION_CODE (decl) = code;
6577
6578   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6579
6580   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6581      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6582      function in the namespace.  */
6583   pushdecl (decl);
6584   if (libname)
6585     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6586   make_function_rtl (decl);
6587   return decl;
6588 }
6589
6590 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6591    function.  Not called directly.  */
6592
6593 static tree
6594 build_library_fn_1 (name, type)
6595      tree name;
6596      tree type;
6597 {
6598   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6599   DECL_EXTERNAL (fn) = 1;
6600   TREE_PUBLIC (fn) = 1;
6601   DECL_ARTIFICIAL (fn) = 1;
6602   TREE_NOTHROW (fn) = 1;
6603   return fn;
6604 }
6605
6606 /* Returns the _DECL for a library function with C linkage.
6607    We assume that such functions never throw; if this is incorrect,
6608    callers should unset TREE_NOTHROW.  */
6609
6610 tree
6611 build_library_fn (name, type)
6612      tree name;
6613      tree type;
6614 {
6615   tree fn = build_library_fn_1 (name, type);
6616   make_function_rtl (fn);
6617   return fn;
6618 }
6619
6620 /* Returns the _DECL for a library function with C++ linkage.  */
6621
6622 tree
6623 build_cp_library_fn (name, type)
6624      tree name;
6625      tree type;
6626 {
6627   tree fn = build_library_fn_1 (name, type);
6628   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6629   set_mangled_name_for_decl (fn);
6630   make_function_rtl (fn);
6631   return fn;
6632 }
6633
6634 /* Like build_library_fn, but takes a C string instead of an
6635    IDENTIFIER_NODE.  */
6636
6637 tree
6638 build_library_fn_ptr (name, type)
6639      const char *name;
6640      tree type;
6641 {
6642   return build_library_fn (get_identifier (name), type);
6643 }
6644
6645 /* Like build_cp_library_fn, but takes a C string instead of an
6646    IDENTIFIER_NODE.  */
6647
6648 tree
6649 build_cp_library_fn_ptr (name, type)
6650      const char *name;
6651      tree type;
6652 {
6653   return build_cp_library_fn (get_identifier (name), type);
6654 }
6655
6656 /* Like build_library_fn, but also pushes the function so that we will
6657    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6658
6659 tree
6660 push_library_fn (name, type)
6661      tree name, type;
6662 {
6663   tree fn = build_library_fn (name, type);
6664   pushdecl_top_level (fn);
6665   return fn;
6666 }
6667
6668 /* Like build_cp_library_fn, but also pushes the function so that it
6669    will be found by normal lookup.  */
6670
6671 tree
6672 push_cp_library_fn (name, type)
6673      tree name;
6674      tree type;
6675 {
6676   tree fn = build_cp_library_fn (name, type);
6677   pushdecl (fn);
6678   return fn;
6679 }
6680
6681 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6682    a FUNCTION_TYPE.  */
6683
6684 tree
6685 push_void_library_fn (name, parmtypes)
6686      tree name, parmtypes;
6687 {
6688   tree type = build_function_type (void_type_node, parmtypes);
6689   return push_library_fn (name, type);
6690 }
6691
6692 /* Like push_library_fn, but also note that this function throws
6693    and does not return.  Used for __throw_foo and the like.  */
6694
6695 tree
6696 push_throw_library_fn (name, type)
6697      tree name, type;
6698 {
6699   tree fn = push_library_fn (name, type);
6700   TREE_THIS_VOLATILE (fn) = 1;
6701   TREE_NOTHROW (fn) = 0;
6702   return fn;
6703 }
6704 \f
6705 /* When we call finish_struct for an anonymous union, we create
6706    default copy constructors and such.  But, an anonymous union
6707    shouldn't have such things; this function undoes the damage to the
6708    anonymous union type T.
6709
6710    (The reason that we create the synthesized methods is that we don't
6711    distinguish `union { int i; }' from `typedef union { int i; } U'.
6712    The first is an anonymous union; the second is just an ordinary
6713    union type.)  */
6714
6715 void
6716 fixup_anonymous_aggr (t)
6717      tree t;
6718 {
6719   tree *q;
6720
6721   /* Wipe out memory of synthesized methods */
6722   TYPE_HAS_CONSTRUCTOR (t) = 0;
6723   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6724   TYPE_HAS_INIT_REF (t) = 0;
6725   TYPE_HAS_CONST_INIT_REF (t) = 0;
6726   TYPE_HAS_ASSIGN_REF (t) = 0;
6727   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6728
6729   /* Splice the implicitly generated functions out of the TYPE_METHODS
6730      list.  */
6731   q = &TYPE_METHODS (t);
6732   while (*q)
6733     {
6734       if (DECL_ARTIFICIAL (*q))
6735         *q = TREE_CHAIN (*q);
6736       else
6737         q = &TREE_CHAIN (*q);
6738     }
6739
6740   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6741   if (TYPE_METHODS (t))
6742     error ("an anonymous union cannot have function members");
6743 }
6744
6745 /* Make sure that a declaration with no declarator is well-formed, i.e.
6746    just defines a tagged type or anonymous union.
6747
6748    Returns the type defined, if any.  */
6749
6750 tree
6751 check_tag_decl (declspecs)
6752      tree declspecs;
6753 {
6754   int found_type = 0;
6755   tree ob_modifier = NULL_TREE;
6756   register tree link;
6757   register tree t = NULL_TREE;
6758
6759   for (link = declspecs; link; link = TREE_CHAIN (link))
6760     {
6761       register tree value = TREE_VALUE (link);
6762
6763       if (TYPE_P (value))
6764         {
6765           ++found_type;
6766
6767           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6768             {
6769               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6770               t = value;
6771             }
6772         }
6773       else if (value == ridpointers[(int) RID_FRIEND])
6774         {
6775           if (current_class_type == NULL_TREE
6776               || current_scope () != current_class_type)
6777             ob_modifier = value;
6778         }
6779       else if (value == ridpointers[(int) RID_STATIC]
6780                || value == ridpointers[(int) RID_EXTERN]
6781                || value == ridpointers[(int) RID_AUTO]
6782                || value == ridpointers[(int) RID_REGISTER]
6783                || value == ridpointers[(int) RID_INLINE]
6784                || value == ridpointers[(int) RID_VIRTUAL]
6785                || value == ridpointers[(int) RID_CONST]
6786                || value == ridpointers[(int) RID_VOLATILE]
6787                || value == ridpointers[(int) RID_EXPLICIT])
6788         ob_modifier = value;
6789     }
6790
6791   if (found_type > 1)
6792     error ("multiple types in one declaration");
6793
6794   /* Inside a class, we might be in a friend or access declaration.
6795      Until we have a good way of detecting the latter, don't warn.  */
6796   if (t == NULL_TREE && ! current_class_type)
6797     pedwarn ("declaration does not declare anything");
6798
6799   /* Check for an anonymous union.  We're careful
6800      accessing TYPE_IDENTIFIER because some built-in types, like
6801      pointer-to-member types, do not have TYPE_NAME.  */
6802   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6803            && TYPE_NAME (t)
6804            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6805     {
6806       /* Anonymous unions are objects, so they can have specifiers.  */;
6807       SET_ANON_AGGR_TYPE_P (t);
6808
6809       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6810         pedwarn ("ISO C++ prohibits anonymous structs");
6811     }
6812
6813   else if (ob_modifier)
6814     {
6815       if (ob_modifier == ridpointers[(int) RID_INLINE]
6816           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6817         cp_error ("`%D' can only be specified for functions", ob_modifier);
6818       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6819         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6820       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6821         cp_error ("`%D' can only be specified for constructors",
6822                   ob_modifier);
6823       else
6824         cp_error ("`%D' can only be specified for objects and functions",
6825                   ob_modifier);
6826     }
6827
6828   return t;
6829 }
6830
6831 /* Called when a declaration is seen that contains no names to declare.
6832    If its type is a reference to a structure, union or enum inherited
6833    from a containing scope, shadow that tag name for the current scope
6834    with a forward reference.
6835    If its type defines a new named structure or union
6836    or defines an enum, it is valid but we need not do anything here.
6837    Otherwise, it is an error.
6838
6839    C++: may have to grok the declspecs to learn about static,
6840    complain for anonymous unions.  */
6841
6842 void
6843 shadow_tag (declspecs)
6844      tree declspecs;
6845 {
6846   tree t = check_tag_decl (declspecs);
6847
6848   if (t)
6849     maybe_process_partial_specialization (t);
6850
6851   /* This is where the variables in an anonymous union are
6852      declared.  An anonymous union declaration looks like:
6853      union { ... } ;
6854      because there is no declarator after the union, the parser
6855      sends that declaration here.  */
6856   if (t && ANON_AGGR_TYPE_P (t))
6857     {
6858       fixup_anonymous_aggr (t);
6859
6860       if (TYPE_FIELDS (t))
6861         {
6862           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6863                                       NULL_TREE);
6864           finish_anon_union (decl);
6865         }
6866     }
6867 }
6868 \f
6869 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6870
6871 tree
6872 groktypename (typename)
6873      tree typename;
6874 {
6875   if (TREE_CODE (typename) != TREE_LIST)
6876     return typename;
6877   return grokdeclarator (TREE_VALUE (typename),
6878                          TREE_PURPOSE (typename),
6879                          TYPENAME, 0, NULL_TREE);
6880 }
6881
6882 /* Decode a declarator in an ordinary declaration or data definition.
6883    This is called as soon as the type information and variable name
6884    have been parsed, before parsing the initializer if any.
6885    Here we create the ..._DECL node, fill in its type,
6886    and put it on the list of decls for the current context.
6887    The ..._DECL node is returned as the value.
6888
6889    Exception: for arrays where the length is not specified,
6890    the type is left null, to be filled in by `cp_finish_decl'.
6891
6892    Function definitions do not come here; they go to start_function
6893    instead.  However, external and forward declarations of functions
6894    do go through here.  Structure field declarations are done by
6895    grokfield and not through here.  */
6896
6897 /* Set this to zero to debug not using the temporary obstack
6898    to parse initializers.  */
6899 int debug_temp_inits = 1;
6900
6901 tree
6902 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6903      tree declarator, declspecs;
6904      int initialized;
6905      tree attributes, prefix_attributes;
6906 {
6907   register tree decl;
6908   register tree type, tem;
6909   tree context;
6910   extern int have_extern_spec;
6911   extern int used_extern_spec;
6912   tree attrlist;
6913
6914 #if 0
6915   /* See code below that used this.  */
6916   int init_written = initialized;
6917 #endif
6918
6919   /* This should only be done once on the top most decl.  */
6920   if (have_extern_spec && !used_extern_spec)
6921     {
6922       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6923                                   declspecs);
6924       used_extern_spec = 1;
6925     }
6926
6927   if (attributes || prefix_attributes)
6928     attrlist = build_tree_list (attributes, prefix_attributes);
6929   else
6930     attrlist = NULL_TREE;
6931
6932   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6933                          attrlist);
6934
6935   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6936     return NULL_TREE;
6937
6938   type = TREE_TYPE (decl);
6939
6940   if (type == error_mark_node)
6941     return NULL_TREE;
6942
6943   context = DECL_CONTEXT (decl);
6944
6945   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
6946       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
6947     {
6948       /* When parsing the initializer, lookup should use the object's
6949          namespace. */
6950       push_decl_namespace (context);
6951     }
6952
6953   /* We are only interested in class contexts, later. */
6954   if (context && TREE_CODE (context) == NAMESPACE_DECL)
6955     context = NULL_TREE;
6956
6957   if (initialized)
6958     /* Is it valid for this decl to have an initializer at all?
6959        If not, set INITIALIZED to zero, which will indirectly
6960        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6961     switch (TREE_CODE (decl))
6962       {
6963       case TYPE_DECL:
6964         /* typedef foo = bar  means give foo the same type as bar.
6965            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6966            Any other case of an initialization in a TYPE_DECL is an error.  */
6967         if (pedantic || list_length (declspecs) > 1)
6968           {
6969             cp_error ("typedef `%D' is initialized", decl);
6970             initialized = 0;
6971           }
6972         break;
6973
6974       case FUNCTION_DECL:
6975         cp_error ("function `%#D' is initialized like a variable", decl);
6976         initialized = 0;
6977         break;
6978
6979       default:
6980         break;
6981       }
6982
6983   if (initialized)
6984     {
6985       if (! toplevel_bindings_p ()
6986           && DECL_EXTERNAL (decl))
6987         cp_warning ("declaration of `%#D' has `extern' and is initialized",
6988                     decl);
6989       DECL_EXTERNAL (decl) = 0;
6990       if (toplevel_bindings_p ())
6991         TREE_STATIC (decl) = 1;
6992
6993       /* Tell `pushdecl' this is an initialized decl
6994          even though we don't yet have the initializer expression.
6995          Also tell `cp_finish_decl' it may store the real initializer.  */
6996       DECL_INITIAL (decl) = error_mark_node;
6997     }
6998
6999 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7000   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7001 #endif
7002
7003   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7004   cplus_decl_attributes (decl, attributes, prefix_attributes);
7005
7006   if (context && COMPLETE_TYPE_P (complete_type (context)))
7007     {
7008       push_nested_class (context, 2);
7009
7010       if (TREE_CODE (decl) == VAR_DECL)
7011         {
7012           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7013           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7014             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7015           else
7016             {
7017               if (DECL_CONTEXT (field) != context)
7018                 {
7019                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7020                               DECL_CONTEXT (field), DECL_NAME (decl),
7021                               context, DECL_NAME (decl));
7022                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7023                 }
7024               /* Static data member are tricky; an in-class initialization
7025                  still doesn't provide a definition, so the in-class
7026                  declaration will have DECL_EXTERNAL set, but will have an
7027                  initialization.  Thus, duplicate_decls won't warn
7028                  about this situation, and so we check here.  */
7029               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7030                 cp_error ("duplicate initialization of %D", decl);
7031               if (duplicate_decls (decl, field))
7032                 decl = field;
7033             }
7034         }
7035       else
7036         {
7037           tree field = check_classfn (context, decl);
7038           if (field && duplicate_decls (decl, field))
7039             decl = field;
7040         }
7041
7042       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7043       DECL_IN_AGGR_P (decl) = 0;
7044       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7045           || CLASSTYPE_USE_TEMPLATE (context))
7046         {
7047           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7048           /* [temp.expl.spec] An explicit specialization of a static data
7049              member of a template is a definition if the declaration
7050              includes an initializer; otherwise, it is a declaration.
7051
7052              We check for processing_specialization so this only applies
7053              to the new specialization syntax.  */
7054           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7055             DECL_EXTERNAL (decl) = 1;
7056         }
7057
7058       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7059         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7060                     decl);
7061     }
7062
7063   /* Enter this declaration into the symbol table.  */
7064   tem = maybe_push_decl (decl);
7065
7066   if (processing_template_decl)
7067     tem = push_template_decl (tem);
7068
7069 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7070   /* Tell the back-end to use or not use .common as appropriate.  If we say
7071      -fconserve-space, we want this to save .data space, at the expense of
7072      wrong semantics.  If we say -fno-conserve-space, we want this to
7073      produce errors about redefs; to do this we force variables into the
7074      data segment.  */
7075   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7076 #endif
7077
7078   if (! processing_template_decl)
7079     start_decl_1 (tem);
7080
7081   return tem;
7082 }
7083
7084 void
7085 start_decl_1 (decl)
7086      tree decl;
7087 {
7088   tree type = TREE_TYPE (decl);
7089   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7090
7091   if (type == error_mark_node)
7092     return;
7093
7094   /* If this type of object needs a cleanup, but we're not allowed to
7095      add any more objects with cleanups to the current scope, create a
7096      new binding level.  */
7097   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7098       && current_binding_level->more_cleanups_ok == 0)
7099     {
7100       keep_next_level (2);
7101       pushlevel (1);
7102       clear_last_expr ();
7103       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7104     }
7105
7106   if (initialized)
7107     /* Is it valid for this decl to have an initializer at all?
7108        If not, set INITIALIZED to zero, which will indirectly
7109        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7110     {
7111       /* Don't allow initializations for incomplete types except for
7112          arrays which might be completed by the initialization.  */
7113       if (COMPLETE_TYPE_P (complete_type (type)))
7114         ;                       /* A complete type is ok.  */
7115       else if (TREE_CODE (type) != ARRAY_TYPE)
7116         {
7117           cp_error ("variable `%#D' has initializer but incomplete type",
7118                     decl);
7119           initialized = 0;
7120           type = TREE_TYPE (decl) = error_mark_node;
7121         }
7122       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7123         {
7124           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7125             cp_error ("elements of array `%#D' have incomplete type", decl);
7126           /* else we already gave an error in start_decl.  */
7127           initialized = 0;
7128         }
7129     }
7130
7131   if (!initialized
7132       && TREE_CODE (decl) != TYPE_DECL
7133       && TREE_CODE (decl) != TEMPLATE_DECL
7134       && type != error_mark_node
7135       && IS_AGGR_TYPE (type)
7136       && ! DECL_EXTERNAL (decl))
7137     {
7138       if ((! processing_template_decl || ! uses_template_parms (type))
7139           && !COMPLETE_TYPE_P (complete_type (type)))
7140         {
7141           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7142                  decl);
7143           /* Change the type so that assemble_variable will give
7144              DECL an rtl we can live with: (mem (const_int 0)).  */
7145           type = TREE_TYPE (decl) = error_mark_node;
7146         }
7147       else
7148         {
7149           /* If any base type in the hierarchy of TYPE needs a constructor,
7150              then we set initialized to 1.  This way any nodes which are
7151              created for the purposes of initializing this aggregate
7152              will live as long as it does.  This is necessary for global
7153              aggregates which do not have their initializers processed until
7154              the end of the file.  */
7155           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7156         }
7157     }
7158
7159   if (! initialized)
7160     DECL_INITIAL (decl) = NULL_TREE;
7161 }
7162
7163 /* Handle initialization of references.
7164    These three arguments are from `cp_finish_decl', and have the
7165    same meaning here that they do there.
7166
7167    Quotes on semantics can be found in ARM 8.4.3.  */
7168
7169 static void
7170 grok_reference_init (decl, type, init)
7171      tree decl, type, init;
7172 {
7173   tree tmp;
7174
7175   if (init == NULL_TREE)
7176     {
7177       if ((DECL_LANG_SPECIFIC (decl) == 0
7178            || DECL_IN_AGGR_P (decl) == 0)
7179           && ! DECL_THIS_EXTERN (decl))
7180         cp_error ("`%D' declared as reference but not initialized", decl);
7181       return;
7182     }
7183
7184   if (init == error_mark_node)
7185     return;
7186
7187   if (TREE_CODE (init) == CONSTRUCTOR)
7188     {
7189       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7190       return;
7191     }
7192
7193   if (TREE_CODE (init) == TREE_LIST)
7194     init = build_compound_expr (init);
7195
7196   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7197     init = convert_from_reference (init);
7198
7199   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7200       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7201     {
7202       /* Note: default conversion is only called in very special cases.  */
7203       init = default_conversion (init);
7204     }
7205
7206   /* Convert INIT to the reference type TYPE.  This may involve the
7207      creation of a temporary, whose lifetime must be the same as that
7208      of the reference.  If so, a DECL_STMT for the temporary will be
7209      added just after the DECL_STMT for DECL.  That's why we don't set
7210      DECL_INITIAL for local references (instead assigning to them
7211      explicitly); we need to allow the temporary to be initialized
7212      first.  */
7213   tmp = convert_to_reference
7214     (type, init, CONV_IMPLICIT,
7215      LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
7216
7217   if (tmp == error_mark_node)
7218     return;
7219   else if (tmp != NULL_TREE)
7220     {
7221       init = tmp;
7222       tmp = save_expr (tmp);
7223       if (building_stmt_tree ())
7224         {
7225           /* Initialize the declaration.  */
7226           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7227           finish_expr_stmt (tmp);
7228         }
7229       else
7230         DECL_INITIAL (decl) = tmp;
7231     }
7232   else
7233     {
7234       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7235       return;
7236     }
7237
7238   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7239     {
7240       expand_static_init (decl, DECL_INITIAL (decl));
7241       DECL_INITIAL (decl) = NULL_TREE;
7242     }
7243   return;
7244 }
7245
7246 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7247    mucking with forces it does not comprehend (i.e. initialization with a
7248    constructor).  If we are at global scope and won't go into COMMON, fill
7249    it in with a dummy CONSTRUCTOR to force the variable into .data;
7250    otherwise we can use error_mark_node.  */
7251
7252 static tree
7253 obscure_complex_init (decl, init)
7254      tree decl, init;
7255 {
7256   if (! flag_no_inline && TREE_STATIC (decl))
7257     {
7258       if (extract_init (decl, init))
7259         return NULL_TREE;
7260     }
7261
7262 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7263   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7264     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7265                                  NULL_TREE);
7266   else
7267 #endif
7268     DECL_INITIAL (decl) = error_mark_node;
7269
7270   return init;
7271 }
7272
7273 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7274    array until we finish parsing the initializer.  If that's the
7275    situation we're in, update DECL accordingly.  */
7276
7277 static void
7278 maybe_deduce_size_from_array_init (decl, init)
7279      tree decl;
7280      tree init;
7281 {
7282   tree type = TREE_TYPE (decl);
7283
7284   if (TREE_CODE (type) == ARRAY_TYPE
7285       && TYPE_DOMAIN (type) == NULL_TREE
7286       && TREE_CODE (decl) != TYPE_DECL)
7287     {
7288       int do_default
7289         = (TREE_STATIC (decl)
7290            /* Even if pedantic, an external linkage array
7291               may have incomplete type at first.  */
7292            ? pedantic && ! DECL_EXTERNAL (decl)
7293            : !DECL_EXTERNAL (decl));
7294       tree initializer = init ? init : DECL_INITIAL (decl);
7295       int failure = complete_array_type (type, initializer, do_default);
7296
7297       if (failure == 1)
7298         cp_error ("initializer fails to determine size of `%D'", decl);
7299
7300       if (failure == 2)
7301         {
7302           if (do_default)
7303             cp_error ("array size missing in `%D'", decl);
7304           /* If a `static' var's size isn't known, make it extern as
7305              well as static, so it does not get allocated.  If it's not
7306              `static', then don't mark it extern; finish_incomplete_decl
7307              will give it a default size and it will get allocated.  */
7308           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7309             DECL_EXTERNAL (decl) = 1;
7310         }
7311
7312       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7313           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7314                               integer_zero_node))
7315         cp_error ("zero-size array `%D'", decl);
7316
7317       layout_decl (decl, 0);
7318     }
7319 }
7320
7321 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7322    any appropriate error messages regarding the layout.  */
7323
7324 static void
7325 layout_var_decl (decl)
7326      tree decl;
7327 {
7328   tree type = TREE_TYPE (decl);
7329 #if 0
7330   tree ttype = target_type (type);
7331 #endif
7332
7333   /* If we haven't already layed out this declaration, do so now.
7334      Note that we must not call complete type for an external object
7335      because it's type might involve templates that we are not
7336      supposed to isntantiate yet.  (And it's perfectly legal to say
7337      `extern X x' for some incomplete type `X'.)  */
7338   if (!DECL_EXTERNAL (decl))
7339     complete_type (type);
7340   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7341     layout_decl (decl, 0);
7342
7343   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7344     {
7345       /* An automatic variable with an incomplete type: that is an error.
7346          Don't talk about array types here, since we took care of that
7347          message in grokdeclarator.  */
7348       cp_error ("storage size of `%D' isn't known", decl);
7349       TREE_TYPE (decl) = error_mark_node;
7350     }
7351 #if 0
7352   /* Keep this code around in case we later want to control debug info
7353      based on whether a type is "used".  (jason 1999-11-11) */
7354
7355   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7356     /* Let debugger know it should output info for this type.  */
7357     note_debug_info_needed (ttype);
7358
7359   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7360     note_debug_info_needed (DECL_CONTEXT (decl));
7361 #endif
7362
7363   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7364       && DECL_SIZE (decl) != NULL_TREE
7365       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7366     {
7367       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7368         constant_expression_warning (DECL_SIZE (decl));
7369       else
7370         cp_error ("storage size of `%D' isn't constant", decl);
7371     }
7372 }
7373
7374 /* If a local static variable is declared in an inline function, or if
7375    we have a weak definition, we must endeavor to create only one
7376    instance of the variable at link-time.  */
7377
7378 static void
7379 maybe_commonize_var (decl)
7380      tree decl;
7381 {
7382   /* Static data in a function with comdat linkage also has comdat
7383      linkage.  */
7384   if (TREE_STATIC (decl)
7385       /* Don't mess with __FUNCTION__.  */
7386       && ! DECL_ARTIFICIAL (decl)
7387       && current_function_decl
7388       && DECL_CONTEXT (decl) == current_function_decl
7389       && (DECL_THIS_INLINE (current_function_decl)
7390           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7391       && TREE_PUBLIC (current_function_decl))
7392     {
7393       /* Rather than try to get this right with inlining, we suppress
7394          inlining of such functions.  */
7395       current_function_cannot_inline
7396         = "function with static variable cannot be inline";
7397
7398       /* If flag_weak, we don't need to mess with this, as we can just
7399          make the function weak, and let it refer to its unique local
7400          copy.  This works because we don't allow the function to be
7401          inlined.  */
7402       if (! flag_weak)
7403         {
7404           if (DECL_INTERFACE_KNOWN (current_function_decl))
7405             {
7406               TREE_PUBLIC (decl) = 1;
7407               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7408             }
7409           else if (DECL_INITIAL (decl) == NULL_TREE
7410                    || DECL_INITIAL (decl) == error_mark_node)
7411             {
7412               TREE_PUBLIC (decl) = 1;
7413               DECL_COMMON (decl) = 1;
7414             }
7415           /* else we lose. We can only do this if we can use common,
7416              which we can't if it has been initialized.  */
7417
7418           if (TREE_PUBLIC (decl))
7419             DECL_ASSEMBLER_NAME (decl)
7420               = build_static_name (current_function_decl, DECL_NAME (decl));
7421           else
7422             {
7423               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7424               cp_warning_at ("  you can work around this by removing the initializer", decl);
7425             }
7426         }
7427     }
7428   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7429     /* Set it up again; we might have set DECL_INITIAL since the last
7430        time.  */
7431     comdat_linkage (decl);
7432 }
7433
7434 /* Issue an error message if DECL is an uninitialized const variable.  */
7435
7436 static void
7437 check_for_uninitialized_const_var (decl)
7438      tree decl;
7439 {
7440   tree type = TREE_TYPE (decl);
7441
7442   /* ``Unless explicitly declared extern, a const object does not have
7443      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7444      7.1.6 */
7445   if (TREE_CODE (decl) == VAR_DECL
7446       && TREE_CODE (type) != REFERENCE_TYPE
7447       && CP_TYPE_CONST_P (type)
7448       && !TYPE_NEEDS_CONSTRUCTING (type)
7449       && !DECL_INITIAL (decl))
7450     cp_error ("uninitialized const `%D'", decl);
7451 }
7452
7453 /* Verify INIT (the initializer for DECL), and record the
7454    initialization in DECL_INITIAL, if appropriate.  Returns a new
7455    value for INIT.  */
7456
7457 static tree
7458 check_initializer (decl, init)
7459      tree decl;
7460      tree init;
7461 {
7462   tree type;
7463
7464   if (TREE_CODE (decl) == FIELD_DECL)
7465     return init;
7466
7467   type = TREE_TYPE (decl);
7468
7469   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7470   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7471     init = NULL_TREE;
7472
7473   /* Check the initializer.  */
7474   if (init)
7475     {
7476       /* Things that are going to be initialized need to have complete
7477          type.  */
7478       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7479
7480       if (type == error_mark_node)
7481         /* We will have already complained.  */
7482         init = NULL_TREE;
7483       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7484         {
7485           cp_error ("variable-sized object `%D' may not be initialized", decl);
7486           init = NULL_TREE;
7487         }
7488       else if (TREE_CODE (type) == ARRAY_TYPE
7489                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7490         {
7491           cp_error ("elements of array `%#D' have incomplete type", decl);
7492           init = NULL_TREE;
7493         }
7494       else if (!COMPLETE_TYPE_P (type))
7495         {
7496           cp_error ("`%D' has incomplete type", decl);
7497           TREE_TYPE (decl) = error_mark_node;
7498           init = NULL_TREE;
7499         }
7500     }
7501
7502   if (TREE_CODE (decl) == CONST_DECL)
7503     {
7504       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7505
7506       DECL_INITIAL (decl) = init;
7507
7508       /* This will keep us from needing to worry about our obstacks.  */
7509       my_friendly_assert (init != NULL_TREE, 149);
7510       init = NULL_TREE;
7511     }
7512   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7513     {
7514       if (TREE_STATIC (decl))
7515         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7516       grok_reference_init (decl, type, init);
7517       init = NULL_TREE;
7518     }
7519   else if (init)
7520     {
7521       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7522         {
7523           if (TREE_CODE (type) == ARRAY_TYPE)
7524             init = digest_init (type, init, (tree *) 0);
7525           else if (TREE_CODE (init) == CONSTRUCTOR
7526                    && TREE_HAS_CONSTRUCTOR (init))
7527             {
7528               if (TYPE_NON_AGGREGATE_CLASS (type))
7529                 {
7530                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7531                             decl);
7532                   init = error_mark_node;
7533                 }
7534               else
7535                 goto dont_use_constructor;
7536             }
7537         }
7538       else
7539         {
7540         dont_use_constructor:
7541           if (TREE_CODE (init) != TREE_VEC)
7542             init = store_init_value (decl, init);
7543         }
7544
7545       if (init)
7546         /* We must hide the initializer so that expand_decl
7547            won't try to do something it does not understand.  */
7548         init = obscure_complex_init (decl, init);
7549     }
7550   else if (DECL_EXTERNAL (decl))
7551     ;
7552   else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
7553            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7554     {
7555       tree core_type = strip_array_types (type);
7556
7557       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7558         {
7559           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7560             cp_error ("structure `%D' with uninitialized const members", decl);
7561           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7562             cp_error ("structure `%D' with uninitialized reference members",
7563                       decl);
7564         }
7565
7566       check_for_uninitialized_const_var (decl);
7567
7568       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7569         init = obscure_complex_init (decl, NULL_TREE);
7570
7571     }
7572   else
7573     check_for_uninitialized_const_var (decl);
7574
7575   return init;
7576 }
7577
7578 /* If DECL is not a local variable, give it RTL.  */
7579
7580 static void
7581 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7582      tree decl;
7583      tree init;
7584      const char *asmspec;
7585 {
7586   int toplev;
7587   tree type;
7588
7589   type = TREE_TYPE (decl);
7590   toplev = toplevel_bindings_p ();
7591
7592   /* Handle non-variables up front.  */
7593   if (TREE_CODE (decl) != VAR_DECL)
7594     {
7595       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7596       return;
7597     }
7598
7599   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7600   if (asmspec)
7601     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7602
7603   if (DECL_VIRTUAL_P (decl))
7604     make_decl_rtl (decl, NULL_PTR, toplev);
7605   else if (TREE_READONLY (decl)
7606            && DECL_INITIAL (decl) != NULL_TREE
7607            && DECL_INITIAL (decl) != error_mark_node
7608            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7609     {
7610       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7611
7612       if (toplev && ! TREE_PUBLIC (decl))
7613         {
7614           /* If this is a static const, change its apparent linkage
7615              if it belongs to a #pragma interface.  */
7616           if (!interface_unknown)
7617             {
7618               TREE_PUBLIC (decl) = 1;
7619               DECL_EXTERNAL (decl) = interface_only;
7620             }
7621           make_decl_rtl (decl, asmspec, toplev);
7622         }
7623       else if (toplev)
7624         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7625     }
7626   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7627     {
7628       my_friendly_assert (TREE_STATIC (decl), 19990828);
7629
7630       if (init == NULL_TREE
7631 #ifdef DEFAULT_STATIC_DEFS
7632           /* If this code is dead, then users must
7633              explicitly declare static member variables
7634              outside the class def'n as well.  */
7635           && TYPE_NEEDS_CONSTRUCTING (type)
7636 #endif
7637           )
7638         {
7639           DECL_EXTERNAL (decl) = 1;
7640           make_decl_rtl (decl, asmspec, 1);
7641         }
7642       else
7643         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7644     }
7645   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7646            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7647     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7648 }
7649
7650 /* Create RTL for the local static variable DECL.  */
7651
7652 void
7653 make_rtl_for_local_static (decl)
7654      tree decl;
7655 {
7656   const char *asmspec = NULL;
7657
7658   /* If we inlined this variable, we could see it's declaration
7659      again.  */
7660   if (DECL_RTL (decl))
7661     return;
7662
7663   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7664     {
7665       /* The only way this situaton can occur is if the
7666          user specified a name for this DECL using the
7667          `attribute' syntax.  */
7668       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7669       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7670     }
7671
7672   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7673 }
7674
7675 /* The old ARM scoping rules injected variables declared in the
7676    initialization statement of a for-statement into the surrounding
7677    scope.  We support this usage, in order to be backward-compatible.
7678    DECL is a just-declared VAR_DECL; if necessary inject its
7679    declaration into the surrounding scope.  */
7680
7681 void
7682 maybe_inject_for_scope_var (decl)
7683      tree decl;
7684 {
7685   if (current_binding_level->is_for_scope)
7686     {
7687       struct binding_level *outer
7688         = current_binding_level->level_chain;
7689
7690       /* Check to see if the same name is already bound at the outer
7691          level, either because it was directly declared, or because a
7692          dead for-decl got preserved.  In either case, the code would
7693          not have been valid under the ARM scope rules, so clear
7694          is_for_scope for the current_binding_level.
7695
7696          Otherwise, we need to preserve the temp slot for decl to last
7697          into the outer binding level.  */
7698
7699       tree outer_binding
7700         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7701
7702       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7703           && (TREE_CODE (BINDING_VALUE (outer_binding))
7704               == VAR_DECL)
7705           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7706         {
7707           BINDING_VALUE (outer_binding)
7708             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7709           current_binding_level->is_for_scope = 0;
7710         }
7711       else if (DECL_IN_MEMORY_P (decl))
7712         preserve_temp_slots (DECL_RTL (decl));
7713     }
7714 }
7715
7716 /* Generate code to initialize DECL (a local variable).  */
7717
7718 void
7719 initialize_local_var (decl, init, flags)
7720      tree decl;
7721      tree init;
7722      int flags;
7723 {
7724   tree type = TREE_TYPE (decl);
7725
7726   /* If the type is bogus, don't bother initializing the variable.  */
7727   if (type == error_mark_node)
7728     return;
7729
7730   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7731     {
7732       /* If we used it already as memory, it must stay in memory.  */
7733       DECL_INITIAL (decl) = NULL_TREE;
7734       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7735     }
7736
7737   /* Local statics are handled differently from ordinary automatic
7738      variables.  */
7739   if (TREE_STATIC (decl))
7740     {
7741       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7742           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7743         expand_static_init (decl, init);
7744       return;
7745     }
7746
7747   if (DECL_SIZE (decl) && type != error_mark_node)
7748     {
7749       int already_used;
7750
7751       /* Compute and store the initial value.  */
7752       already_used = TREE_USED (decl) || TREE_USED (type);
7753
7754       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7755         {
7756           int saved_stmts_are_full_exprs_p;
7757
7758           emit_line_note (DECL_SOURCE_FILE (decl),
7759                           DECL_SOURCE_LINE (decl));
7760           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7761           stmts_are_full_exprs_p = 1;
7762           finish_expr_stmt (build_aggr_init (decl, init, flags));
7763           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7764         }
7765
7766       /* Set this to 0 so we can tell whether an aggregate which was
7767          initialized was ever used.  Don't do this if it has a
7768          destructor, so we don't complain about the 'resource
7769          allocation is initialization' idiom.  Now set
7770          attribute((unused)) on types so decls of that type will be
7771          marked used. (see TREE_USED, above.)  */
7772       if (TYPE_NEEDS_CONSTRUCTING (type)
7773           && ! already_used
7774           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7775           && DECL_NAME (decl))
7776         TREE_USED (decl) = 0;
7777       else if (already_used)
7778         TREE_USED (decl) = 1;
7779     }
7780 }
7781
7782 /* Generate code to destroy DECL (a local variable).  */
7783
7784 static void
7785 destroy_local_var (decl)
7786      tree decl;
7787 {
7788   tree type = TREE_TYPE (decl);
7789   tree cleanup;
7790
7791   /* Only variables get cleaned up.  */
7792   if (TREE_CODE (decl) != VAR_DECL)
7793     return;
7794
7795   /* And only things with destructors need cleaning up.  */
7796   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7797     return;
7798
7799   if (TREE_CODE (decl) == VAR_DECL &&
7800       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7801     /* We don't clean up things that aren't defined in this
7802        translation unit, or that need a static cleanup.  The latter
7803        are handled by finish_file.  */
7804     return;
7805
7806   /* Compute the cleanup.  */
7807   cleanup = maybe_build_cleanup (decl);
7808
7809   /* Record the cleanup required for this declaration.  */
7810   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7811       && cleanup)
7812     finish_decl_cleanup (decl, cleanup);
7813 }
7814
7815 /* Let the back-end know about DECL.  */
7816
7817 void
7818 emit_local_var (decl)
7819      tree decl;
7820 {
7821   /* Create RTL for this variable.  */
7822   if (DECL_RTL (decl))
7823     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7824        All other local variables are assigned RTL in this function.  */
7825     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
7826                         19990828);
7827   else
7828     {
7829       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7830         /* The user must have specified an assembler name for this
7831            variable.  Set that up now.  */
7832         rest_of_decl_compilation
7833           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
7834            /*top_level=*/0, /*at_end=*/0);
7835       else
7836         expand_decl (decl);
7837     }
7838
7839   /* Actually do the initialization.  */
7840   expand_start_target_temps ();
7841   expand_decl_init (decl);
7842   expand_end_target_temps ();
7843 }
7844
7845 /* Finish processing of a declaration;
7846    install its line number and initial value.
7847    If the length of an array type is not known before,
7848    it must be determined now, from the initial value, or it is an error.
7849
7850    INIT0 holds the value of an initializer that should be allowed to escape
7851    the normal rules.
7852
7853    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7854    if the (init) syntax was used.  */
7855
7856 void
7857 cp_finish_decl (decl, init, asmspec_tree, flags)
7858      tree decl, init;
7859      tree asmspec_tree;
7860      int flags;
7861 {
7862   register tree type;
7863   tree ttype = NULL_TREE;
7864   const char *asmspec = NULL;
7865   int was_readonly = 0;
7866
7867   if (! decl)
7868     {
7869       if (init)
7870         error ("assignment (not initialization) in declaration");
7871       return;
7872     }
7873
7874   /* If a name was specified, get the string.  */
7875   if (asmspec_tree)
7876       asmspec = TREE_STRING_POINTER (asmspec_tree);
7877
7878   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7879     {
7880       cp_error ("cannot initialize `%D' to namespace `%D'",
7881                 decl, init);
7882       init = NULL_TREE;
7883     }
7884
7885   if (current_class_type
7886       && CP_DECL_CONTEXT (decl) == current_class_type
7887       && TYPE_BEING_DEFINED (current_class_type)
7888       && (DECL_INITIAL (decl) || init))
7889     DECL_DEFINED_IN_CLASS_P (decl) = 1;
7890
7891   if (TREE_CODE (decl) == VAR_DECL
7892       && DECL_CONTEXT (decl)
7893       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7894       && DECL_CONTEXT (decl) != current_namespace
7895       && init)
7896     {
7897       /* Leave the namespace of the object. */
7898       pop_decl_namespace ();
7899     }
7900
7901   type = TREE_TYPE (decl);
7902
7903   if (type == error_mark_node)
7904     return;
7905
7906   /* Add this declaration to the statement-tree.  */
7907   if (building_stmt_tree () && at_function_scope_p ())
7908     add_decl_stmt (decl);
7909
7910   if (TYPE_HAS_MUTABLE_P (type))
7911     TREE_READONLY (decl) = 0;
7912
7913   if (processing_template_decl)
7914     {
7915       if (init && DECL_INITIAL (decl))
7916         DECL_INITIAL (decl) = init;
7917       goto finish_end0;
7918     }
7919
7920   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7921   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7922
7923   /* Take care of TYPE_DECLs up front.  */
7924   if (TREE_CODE (decl) == TYPE_DECL)
7925     {
7926       if (init && DECL_INITIAL (decl))
7927         {
7928           /* typedef foo = bar; store the type of bar as the type of foo.  */
7929           TREE_TYPE (decl) = type = TREE_TYPE (init);
7930           DECL_INITIAL (decl) = init = NULL_TREE;
7931         }
7932       if (type != error_mark_node
7933           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7934         {
7935           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7936             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7937           set_identifier_type_value (DECL_NAME (decl), type);
7938           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7939         }
7940       GNU_xref_decl (current_function_decl, decl);
7941
7942       /* If we have installed this as the canonical typedef for this
7943          type, and that type has not been defined yet, delay emitting
7944          the debug information for it, as we will emit it later.  */
7945       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7946           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
7947         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7948
7949       rest_of_decl_compilation (decl, NULL_PTR,
7950                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7951       goto finish_end;
7952     }
7953
7954   if (TREE_CODE (decl) != FUNCTION_DECL)
7955     ttype = target_type (type);
7956
7957   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7958       && TYPE_NEEDS_CONSTRUCTING (type))
7959     {
7960       /* Currently, GNU C++ puts constants in text space, making them
7961          impossible to initialize.  In the future, one would hope for
7962          an operating system which understood the difference between
7963          initialization and the running of a program.  */
7964       was_readonly = 1;
7965       TREE_READONLY (decl) = 0;
7966     }
7967
7968   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
7969     {
7970       /* This must override the asm specifier which was placed by
7971          grokclassfn.  Lay this out fresh.  */
7972       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
7973       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7974       make_decl_rtl (decl, asmspec, 0);
7975     }
7976
7977   /* Deduce size of array from initialization, if not already known.  */
7978   maybe_deduce_size_from_array_init (decl, init);
7979   init = check_initializer (decl, init);
7980
7981   GNU_xref_decl (current_function_decl, decl);
7982
7983   if (TREE_CODE (decl) == VAR_DECL)
7984     layout_var_decl (decl);
7985
7986   /* Output the assembler code and/or RTL code for variables and functions,
7987      unless the type is an undefined structure or union.
7988      If not, it will get done when the type is completed.  */
7989   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
7990       || TREE_CODE (decl) == RESULT_DECL)
7991     {
7992       if (TREE_CODE (decl) == VAR_DECL)
7993         maybe_commonize_var (decl);
7994
7995       make_rtl_for_nonlocal_decl (decl, init, asmspec);
7996
7997       if (TREE_CODE (type) == FUNCTION_TYPE
7998           || TREE_CODE (type) == METHOD_TYPE)
7999         abstract_virtuals_error (decl,
8000                                  strip_array_types (TREE_TYPE (type)));
8001       else
8002         abstract_virtuals_error (decl, strip_array_types (type));
8003
8004       if (TREE_CODE (decl) == FUNCTION_DECL)
8005         ;
8006       else if (DECL_EXTERNAL (decl)
8007                && ! (DECL_LANG_SPECIFIC (decl)
8008                      && DECL_NOT_REALLY_EXTERN (decl)))
8009         {
8010           if (init)
8011             DECL_INITIAL (decl) = init;
8012         }
8013       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8014         {
8015           /* This is a local declaration.  */
8016           if (doing_semantic_analysis_p ())
8017             maybe_inject_for_scope_var (decl);
8018           /* Initialize the local variable.  But, if we're building a
8019              statement-tree, we'll do the initialization when we
8020              expand the tree.  */
8021           if (processing_template_decl)
8022             {
8023               if (init || DECL_INITIAL (decl) == error_mark_node)
8024                 DECL_INITIAL (decl) = init;
8025             }
8026           else
8027             {
8028               /* If we're not building RTL, then we need to do so
8029                  now.  */
8030               if (!building_stmt_tree ())
8031                 emit_local_var (decl);
8032               /* Initialize the variable.  */
8033               initialize_local_var (decl, init, flags);
8034               /* Clean up the variable.  */
8035               destroy_local_var (decl);
8036             }
8037         }
8038       else if (TREE_STATIC (decl) && type != error_mark_node)
8039         {
8040           /* Cleanups for static variables are handled by `finish_file'.  */
8041           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8042               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8043             expand_static_init (decl, init);
8044         }
8045     finish_end0:
8046
8047       /* Undo call to `pushclass' that was done in `start_decl'
8048          due to initialization of qualified member variable.
8049          I.e., Foo::x = 10;  */
8050       {
8051         tree context = CP_DECL_CONTEXT (decl);
8052         if (context
8053             && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
8054             && (TREE_CODE (decl) == VAR_DECL
8055                 /* We also have a pushclass done that we need to undo here
8056                    if we're at top level and declare a method.  */
8057                 || TREE_CODE (decl) == FUNCTION_DECL)
8058             /* If size hasn't been set, we're still defining it,
8059                and therefore inside the class body; don't pop
8060                the binding level..  */
8061             && COMPLETE_TYPE_P (context)
8062             && context == current_class_type)
8063           pop_nested_class ();
8064       }
8065     }
8066
8067  finish_end:
8068
8069   if (was_readonly)
8070     TREE_READONLY (decl) = 1;
8071 }
8072
8073 /* This is here for a midend callback from c-common.c */
8074
8075 void
8076 finish_decl (decl, init, asmspec_tree)
8077      tree decl, init;
8078      tree asmspec_tree;
8079 {
8080   cp_finish_decl (decl, init, asmspec_tree, 0);
8081 }
8082
8083 /* Returns a declaration for a VAR_DECL as if:
8084
8085      extern "C" TYPE NAME;
8086
8087    had been seen.  Used to create compiler-generated global
8088    variables.  */
8089
8090 tree
8091 declare_global_var (name, type)
8092      tree name;
8093      tree type;
8094 {
8095   tree decl;
8096
8097   push_to_top_level ();
8098   decl = build_decl (VAR_DECL, name, type);
8099   TREE_PUBLIC (decl) = 1;
8100   DECL_EXTERNAL (decl) = 1;
8101   DECL_ARTIFICIAL (decl) = 1;
8102   pushdecl (decl);
8103   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8104   pop_from_top_level ();
8105
8106   return decl;
8107 }
8108
8109 /* Returns a pointer to the `atexit' function.  Note that if
8110    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8111    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8112
8113 static tree
8114 get_atexit_node ()
8115 {
8116   tree atexit_fndecl;
8117   tree arg_types;
8118   tree fn_type;
8119   tree fn_ptr_type;
8120   const char *name;
8121
8122   if (atexit_node)
8123     return atexit_node;
8124
8125   if (flag_use_cxa_atexit)
8126     {
8127       /* The declaration for `__cxa_atexit' is:
8128
8129            int __cxa_atexit (void (*)(void *), void *, void *)
8130
8131          We build up the argument types and then then function type
8132          itself.  */
8133
8134       /* First, build the pointer-to-function type for the first
8135          argument.  */
8136       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8137       fn_type = build_function_type (void_type_node, arg_types);
8138       fn_ptr_type = build_pointer_type (fn_type);
8139       /* Then, build the rest of the argument types.  */
8140       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8141       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8142       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8143       /* And the final __cxa_atexit type.  */
8144       fn_type = build_function_type (integer_type_node, arg_types);
8145       fn_ptr_type = build_pointer_type (fn_type);
8146       name = "__cxa_atexit";
8147     }
8148   else
8149     {
8150       /* The declaration for `atexit' is:
8151
8152            int atexit (void (*)());
8153
8154          We build up the argument types and then then function type
8155          itself.  */
8156       fn_type = build_function_type (void_type_node, void_list_node);
8157       fn_ptr_type = build_pointer_type (fn_type);
8158       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8159       /* Build the final atexit type.  */
8160       fn_type = build_function_type (integer_type_node, arg_types);
8161       name = "atexit";
8162     }
8163
8164   /* Now, build the function declaration.  */
8165   push_lang_context (lang_name_c);
8166   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8167   mark_used (atexit_fndecl);
8168   pop_lang_context ();
8169   atexit_node = default_conversion (atexit_fndecl);
8170
8171   return atexit_node;
8172 }
8173
8174 /* Returns the __dso_handle VAR_DECL.  */
8175
8176 static tree
8177 get_dso_handle_node ()
8178 {
8179   if (dso_handle_node)
8180     return dso_handle_node;
8181
8182   /* Declare the variable.  */
8183   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8184                                         ptr_type_node);
8185
8186   return dso_handle_node;
8187 }
8188
8189 /* Begin a new function with internal linkage whose job will be simply
8190    to destroy some particular variable.  */
8191
8192 static tree
8193 start_cleanup_fn ()
8194 {
8195   static int counter = 0;
8196   int old_interface_unknown = interface_unknown;
8197   char name[32];
8198   tree parmtypes;
8199   tree fntype;
8200   tree fndecl;
8201
8202   push_to_top_level ();
8203
8204   /* No need to mangle this.  */
8205   push_lang_context (lang_name_c);
8206
8207   interface_unknown = 1;
8208
8209   /* Build the parameter-types.  */
8210   parmtypes = void_list_node;
8211   /* Functions passed to __cxa_atexit take an additional parameter.
8212      We'll just ignore it.  After we implement the new calling
8213      convention for destructors, we can eliminate the use of
8214      additional cleanup functions entirely in the -fnew-abi case.  */
8215   if (flag_use_cxa_atexit)
8216     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8217   /* Build the function type itself.  */
8218   fntype = build_function_type (void_type_node, parmtypes);
8219   /* Build the name of the function.  */
8220   sprintf (name, "__tcf_%d", counter++);
8221   /* Build the function declaration.  */
8222   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8223   /* It's a function with internal linkage, generated by the
8224      compiler.  */
8225   TREE_PUBLIC (fndecl) = 0;
8226   DECL_ARTIFICIAL (fndecl) = 1;
8227   /* Build the parameter.  */
8228   if (flag_use_cxa_atexit)
8229     {
8230       tree parmdecl;
8231
8232       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8233       DECL_CONTEXT (parmdecl) = fndecl;
8234       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8235       TREE_USED (parmdecl) = 1;
8236       DECL_ARGUMENTS (fndecl) = parmdecl;
8237     }
8238
8239   pushdecl (fndecl);
8240   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8241   do_pushlevel ();
8242
8243   interface_unknown = old_interface_unknown;
8244
8245   pop_lang_context ();
8246
8247   return current_function_decl;
8248 }
8249
8250 /* Finish the cleanup function begun by start_cleanup_fn.  */
8251
8252 static void
8253 end_cleanup_fn ()
8254 {
8255   do_poplevel ();
8256
8257   expand_body (finish_function (lineno, 0));
8258
8259   pop_from_top_level ();
8260 }
8261
8262 /* Generate code to handle the destruction of DECL, an object with
8263    static storage duration.  */
8264
8265 void
8266 register_dtor_fn (decl)
8267      tree decl;
8268 {
8269   tree cleanup;
8270   tree compound_stmt;
8271   tree args;
8272   tree fcall;
8273
8274   int saved_flag_access_control;
8275
8276   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8277     return;
8278
8279   /* Call build_cleanup before we enter the anonymous function so that
8280      any access checks will be done relative to the current scope,
8281      rather than the scope of the anonymous function.  */
8282   build_cleanup (decl);
8283
8284   /* Now start the function.  */
8285   cleanup = start_cleanup_fn ();
8286
8287   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8288      to the original function, rather than the anonymous one.  That
8289      will make the back-end think that nested functions are in use,
8290      which causes confusion.  */
8291   saved_flag_access_control = flag_access_control;
8292   flag_access_control = 0;
8293   fcall = build_cleanup (decl);
8294   flag_access_control = saved_flag_access_control;
8295
8296   /* Create the body of the anonymous function.  */
8297   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8298   finish_expr_stmt (fcall);
8299   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8300   end_cleanup_fn ();
8301
8302   /* Call atexit with the cleanup function.  */
8303   mark_addressable (cleanup);
8304   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8305   if (flag_use_cxa_atexit)
8306     {
8307       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8308       args = tree_cons (NULL_TREE, null_pointer_node, args);
8309       args = tree_cons (NULL_TREE, cleanup, args);
8310     }
8311   else
8312     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8313   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8314 }
8315
8316 void
8317 expand_static_init (decl, init)
8318      tree decl;
8319      tree init;
8320 {
8321   tree oldstatic = value_member (decl, static_aggregates);
8322
8323   if (oldstatic)
8324     {
8325       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8326         cp_error ("multiple initializations given for `%D'", decl);
8327     }
8328   else if (! toplevel_bindings_p ())
8329     {
8330       /* Emit code to perform this initialization but once.  */
8331       tree temp;
8332       tree if_stmt;
8333       tree then_clause;
8334       tree assignment;
8335       tree temp_init;
8336
8337       /* Emit code to perform this initialization but once.  This code
8338          looks like:
8339
8340            static int temp = 0;
8341            if (!temp) {
8342              // Do initialization.
8343              temp = 1;
8344              // Register variable for destruction at end of program.
8345            }
8346
8347          Note that the `temp' variable is only set to 1 *after* the
8348          initialization is complete.  This ensures that an exception,
8349          thrown during the construction, will cause the variable to
8350          reinitialized when we pass through this code again, as per:
8351
8352            [stmt.dcl]
8353
8354            If the initialization exits by throwing an exception, the
8355            initialization is not complete, so it will be tried again
8356            the next time control enters the declaration.
8357
8358          In theory, this process should be thread-safe, too; multiple
8359          threads should not be able to initialize the variable more
8360          than once.  We don't yet attempt to ensure thread-safety.  */
8361       temp = get_temp_name (integer_type_node, 1);
8362       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8363
8364       /* Begin the conditional initialization.  */
8365       if_stmt = begin_if_stmt ();
8366       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8367                                             integer_zero_node),
8368                            if_stmt);
8369       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8370
8371       /* Do the initialization itself.  */
8372       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8373           || (init && TREE_CODE (init) == TREE_LIST))
8374         assignment = build_aggr_init (decl, init, 0);
8375       else if (init)
8376         /* The initialization we're doing here is just a bitwise
8377            copy.  */
8378         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8379       else
8380         assignment = NULL_TREE;
8381
8382       /* Once the assignment is complete, set TEMP to 1.  Since the
8383          construction of the static object is complete at this point,
8384          we want to make sure TEMP is set to 1 even if a temporary
8385          constructed during the initialization throws an exception
8386          when it is destroyed.  So, we combine the initialization and
8387          the assignment to TEMP into a single expression, ensuring
8388          that when we call finish_expr_stmt the cleanups will not be
8389          run until after TEMP is set to 1.  */
8390       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8391       if (assignment)
8392         {
8393           assignment = tree_cons (NULL_TREE, assignment,
8394                                   build_tree_list (NULL_TREE,
8395                                                    temp_init));
8396           assignment = build_compound_expr (assignment);
8397         }
8398       else
8399         assignment = temp_init;
8400       finish_expr_stmt (assignment);
8401
8402       /* Use atexit to register a function for destroying this static
8403          variable.  */
8404       register_dtor_fn (decl);
8405
8406       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8407       finish_then_clause (if_stmt);
8408       finish_if_stmt ();
8409     }
8410   else
8411     static_aggregates = tree_cons (init, decl, static_aggregates);
8412 }
8413
8414 /* Finish the declaration of a catch-parameter.  */
8415
8416 tree
8417 start_handler_parms (declspecs, declarator)
8418      tree declspecs;
8419      tree declarator;
8420 {
8421   tree decl;
8422   if (declspecs)
8423     {
8424       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8425                              1, NULL_TREE);
8426       if (decl == NULL_TREE)
8427         error ("invalid catch parameter");
8428     }
8429   else
8430     decl = NULL_TREE;
8431
8432   return decl;
8433 }
8434
8435 \f
8436 /* Make TYPE a complete type based on INITIAL_VALUE.
8437    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8438    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8439
8440 int
8441 complete_array_type (type, initial_value, do_default)
8442      tree type, initial_value;
8443      int do_default;
8444 {
8445   register tree maxindex = NULL_TREE;
8446   int value = 0;
8447
8448   if (initial_value)
8449     {
8450       /* Note MAXINDEX  is really the maximum index,
8451          one less than the size.  */
8452       if (TREE_CODE (initial_value) == STRING_CST)
8453         {
8454           int eltsize
8455             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8456           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8457                                    / eltsize) - 1, 0);
8458         }
8459       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8460         {
8461           tree elts = CONSTRUCTOR_ELTS (initial_value);
8462
8463           maxindex = ssize_int (-1);
8464           for (; elts; elts = TREE_CHAIN (elts))
8465             {
8466               if (TREE_PURPOSE (elts))
8467                 maxindex = TREE_PURPOSE (elts);
8468               else
8469                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8470             }
8471           maxindex = copy_node (maxindex);
8472         }
8473       else
8474         {
8475           /* Make an error message unless that happened already.  */
8476           if (initial_value != error_mark_node)
8477             value = 1;
8478           else
8479             initial_value = NULL_TREE;
8480
8481           /* Prevent further error messages.  */
8482           maxindex = build_int_2 (0, 0);
8483         }
8484     }
8485
8486   if (!maxindex)
8487     {
8488       if (do_default)
8489         maxindex = build_int_2 (0, 0);
8490       value = 2;
8491     }
8492
8493   if (maxindex)
8494     {
8495       tree itype;
8496       tree domain;
8497
8498       domain = build_index_type (maxindex);
8499       TYPE_DOMAIN (type) = domain;
8500
8501       if (! TREE_TYPE (maxindex))
8502         TREE_TYPE (maxindex) = domain;
8503       if (initial_value)
8504         itype = TREE_TYPE (initial_value);
8505       else
8506         itype = NULL;
8507       if (itype && !TYPE_DOMAIN (itype))
8508         TYPE_DOMAIN (itype) = domain;
8509       /* The type of the main variant should never be used for arrays
8510          of different sizes.  It should only ever be completed with the
8511          size of the array.  */
8512       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8513         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8514     }
8515
8516   /* Lay out the type now that we can get the real answer.  */
8517
8518   layout_type (type);
8519
8520   return value;
8521 }
8522 \f
8523 /* Return zero if something is declared to be a member of type
8524    CTYPE when in the context of CUR_TYPE.  STRING is the error
8525    message to print in that case.  Otherwise, quietly return 1.  */
8526
8527 static int
8528 member_function_or_else (ctype, cur_type, flags)
8529      tree ctype, cur_type;
8530      enum overload_flags flags;
8531 {
8532   if (ctype && ctype != cur_type)
8533     {
8534       if (flags == DTOR_FLAG)
8535         error ("destructor for alien class `%s' cannot be a member",
8536                TYPE_NAME_STRING (ctype));
8537       else
8538         error ("constructor for alien class `%s' cannot be a member",
8539                TYPE_NAME_STRING (ctype));
8540       return 0;
8541     }
8542   return 1;
8543 }
8544 \f
8545 /* Subroutine of `grokdeclarator'.  */
8546
8547 /* Generate errors possibly applicable for a given set of specifiers.
8548    This is for ARM $7.1.2.  */
8549
8550 static void
8551 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8552      tree object;
8553      const char *type;
8554      int virtualp, quals, friendp, raises, inlinep;
8555 {
8556   if (virtualp)
8557     cp_error ("`%D' declared as a `virtual' %s", object, type);
8558   if (inlinep)
8559     cp_error ("`%D' declared as an `inline' %s", object, type);
8560   if (quals)
8561     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8562               object, type);
8563   if (friendp)
8564     cp_error_at ("`%D' declared as a friend", object);
8565   if (raises)
8566     cp_error_at ("`%D' declared with an exception specification", object);
8567 }
8568
8569 /* CTYPE is class type, or null if non-class.
8570    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8571    or METHOD_TYPE.
8572    DECLARATOR is the function's name.
8573    VIRTUALP is truthvalue of whether the function is virtual or not.
8574    FLAGS are to be passed through to `grokclassfn'.
8575    QUALS are qualifiers indicating whether the function is `const'
8576    or `volatile'.
8577    RAISES is a list of exceptions that this function can raise.
8578    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8579    not look, and -1 if we should not call `grokclassfn' at all.
8580
8581    Returns `NULL_TREE' if something goes wrong, after issuing
8582    applicable error messages.  */
8583
8584 static tree
8585 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8586             raises, check, friendp, publicp, inlinep, funcdef_flag,
8587             template_count, in_namespace)
8588      tree ctype, type;
8589      tree declarator;
8590      tree orig_declarator;
8591      int virtualp;
8592      enum overload_flags flags;
8593      tree quals, raises;
8594      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8595      tree in_namespace;
8596 {
8597   tree cname, decl;
8598   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8599   int has_default_arg = 0;
8600   tree t;
8601
8602   if (ctype)
8603     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8604       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8605   else
8606     cname = NULL_TREE;
8607
8608   if (raises)
8609     {
8610       type = build_exception_variant (type, raises);
8611     }
8612
8613   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8614   /* Propagate volatile out from type to decl. */
8615   if (TYPE_VOLATILE (type))
8616     TREE_THIS_VOLATILE (decl) = 1;
8617
8618   /* If this decl has namespace scope, set that up.  */
8619   if (in_namespace)
8620     set_decl_namespace (decl, in_namespace, friendp);
8621   else if (publicp && ! ctype)
8622     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8623
8624   /* `main' and builtins have implicit 'C' linkage.  */
8625   if ((MAIN_NAME_P (declarator)
8626        || (IDENTIFIER_LENGTH (declarator) > 10
8627            && IDENTIFIER_POINTER (declarator)[0] == '_'
8628            && IDENTIFIER_POINTER (declarator)[1] == '_'
8629            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8630       && current_lang_name == lang_name_cplusplus
8631       && ctype == NULL_TREE
8632       /* NULL_TREE means global namespace.  */
8633       && DECL_CONTEXT (decl) == NULL_TREE)
8634     DECL_LANGUAGE (decl) = lang_c;
8635
8636   /* Should probably propagate const out from type to decl I bet (mrs).  */
8637   if (staticp)
8638     {
8639       DECL_STATIC_FUNCTION_P (decl) = 1;
8640       DECL_CONTEXT (decl) = ctype;
8641     }
8642
8643   if (ctype)
8644     DECL_CONTEXT (decl) = ctype;
8645
8646   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8647     {
8648       if (processing_template_decl)
8649         error ("cannot declare `::main' to be a template");
8650       if (inlinep)
8651         error ("cannot declare `::main' to be inline");
8652       else if (! publicp)
8653         error ("cannot declare `::main' to be static");
8654       inlinep = 0;
8655       publicp = 1;
8656     }
8657
8658   /* Members of anonymous types and local classes have no linkage; make
8659      them internal.  */
8660   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8661                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8662     publicp = 0;
8663
8664   if (publicp)
8665     {
8666       /* [basic.link]: A name with no linkage (notably, the name of a class
8667          or enumeration declared in a local scope) shall not be used to
8668          declare an entity with linkage.
8669
8670          Only check this for public decls for now.  */
8671       t = no_linkage_check (TREE_TYPE (decl));
8672       if (t)
8673         {
8674           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8675             {
8676               if (DECL_LANGUAGE (decl) == lang_c)
8677                 /* Allow this; it's pretty common in C.  */;
8678               else
8679                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8680                             decl);
8681             }
8682           else
8683             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8684                         decl, t);
8685         }
8686     }
8687
8688   TREE_PUBLIC (decl) = publicp;
8689   if (! publicp)
8690     {
8691       DECL_INTERFACE_KNOWN (decl) = 1;
8692       DECL_NOT_REALLY_EXTERN (decl) = 1;
8693     }
8694
8695   if (inlinep)
8696     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8697
8698   DECL_EXTERNAL (decl) = 1;
8699   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8700     {
8701       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8702                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8703       quals = NULL_TREE;
8704     }
8705
8706   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8707     grok_op_properties (decl, virtualp, check < 0);
8708
8709   if (ctype && decl_function_context (decl))
8710     DECL_NO_STATIC_CHAIN (decl) = 1;
8711
8712   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8713     if (TREE_PURPOSE (t)
8714         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8715       {
8716         has_default_arg = 1;
8717         break;
8718       }
8719
8720   if (friendp
8721       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8722     {
8723       if (funcdef_flag)
8724         cp_error
8725           ("defining explicit specialization `%D' in friend declaration",
8726            orig_declarator);
8727       else
8728         {
8729           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8730             {
8731               /* Something like `template <class T> friend void f<T>()'.  */
8732               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8733                         orig_declarator);
8734               return NULL_TREE;
8735             }
8736
8737
8738           /* A friend declaration of the form friend void f<>().  Record
8739              the information in the TEMPLATE_ID_EXPR.  */
8740           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8741           DECL_TEMPLATE_INFO (decl)
8742             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8743                          TREE_OPERAND (orig_declarator, 1),
8744                          NULL_TREE);
8745
8746           if (has_default_arg)
8747             {
8748               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8749                         decl);
8750               return NULL_TREE;
8751             }
8752
8753           if (inlinep)
8754             {
8755               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8756                         decl);
8757               return NULL_TREE;
8758             }
8759         }
8760     }
8761
8762   if (has_default_arg)
8763     add_defarg_fn (decl);
8764
8765   /* Plain overloading: will not be grok'd by grokclassfn.  */
8766   if (! ctype && ! processing_template_decl
8767       && DECL_LANGUAGE (decl) != lang_c
8768       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8769     set_mangled_name_for_decl (decl);
8770
8771   if (funcdef_flag)
8772     /* Make the init_value nonzero so pushdecl knows this is not
8773        tentative.  error_mark_node is replaced later with the BLOCK.  */
8774     DECL_INITIAL (decl) = error_mark_node;
8775
8776   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8777     TREE_NOTHROW (decl) = 1;
8778
8779   /* Caller will do the rest of this.  */
8780   if (check < 0)
8781     return decl;
8782
8783   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8784     DECL_CONSTRUCTOR_P (decl) = 1;
8785
8786   /* Function gets the ugly name, field gets the nice one.  This call
8787      may change the type of the function (because of default
8788      parameters)!  */
8789   if (ctype != NULL_TREE)
8790     grokclassfn (ctype, decl, flags, quals);
8791
8792   decl = check_explicit_specialization (orig_declarator, decl,
8793                                         template_count,
8794                                         2 * (funcdef_flag != 0) +
8795                                         4 * (friendp != 0));
8796   if (decl == error_mark_node)
8797     return NULL_TREE;
8798
8799   if (ctype != NULL_TREE
8800       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8801       && check)
8802     {
8803       tree old_decl;
8804
8805       old_decl = check_classfn (ctype, decl);
8806
8807       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8808         /* Because grokfndecl is always supposed to return a
8809            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8810            here.  We depend on our callers to figure out that its
8811            really a template that's being returned.  */
8812         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8813
8814       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8815           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8816         {
8817           /* Remove the `this' parm added by grokclassfn.
8818              XXX Isn't this done in start_function, too?  */
8819           revert_static_member_fn (decl);
8820           last_function_parms = TREE_CHAIN (last_function_parms);
8821         }
8822       if (old_decl && DECL_ARTIFICIAL (old_decl))
8823         cp_error ("definition of implicitly-declared `%D'", old_decl);
8824
8825       if (old_decl)
8826         {
8827           /* Since we've smashed OLD_DECL to its
8828              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8829           if (TREE_CODE (decl) == TEMPLATE_DECL)
8830             decl = DECL_TEMPLATE_RESULT (decl);
8831
8832           /* Attempt to merge the declarations.  This can fail, in
8833              the case of some illegal specialization declarations.  */
8834           if (!duplicate_decls (decl, old_decl))
8835             cp_error ("no `%#D' member function declared in class `%T'",
8836                       decl, ctype);
8837           return old_decl;
8838         }
8839     }
8840
8841   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8842     return NULL_TREE;
8843
8844   if (ctype == NULL_TREE || check)
8845     return decl;
8846
8847   if (virtualp)
8848     {
8849       DECL_VIRTUAL_P (decl) = 1;
8850       if (DECL_VINDEX (decl) == NULL_TREE)
8851         DECL_VINDEX (decl) = error_mark_node;
8852       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8853     }
8854
8855   return decl;
8856 }
8857
8858 static tree
8859 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8860      tree type;
8861      tree declarator;
8862      RID_BIT_TYPE *specbits_in;
8863      int initialized;
8864      int constp;
8865      tree in_namespace;
8866 {
8867   tree decl;
8868   RID_BIT_TYPE specbits;
8869
8870   specbits = *specbits_in;
8871
8872   if (TREE_CODE (type) == OFFSET_TYPE)
8873     {
8874       /* If you declare a static member so that it
8875          can be initialized, the code will reach here.  */
8876       tree basetype = TYPE_OFFSET_BASETYPE (type);
8877       type = TREE_TYPE (type);
8878       decl = build_lang_decl (VAR_DECL, declarator, type);
8879       DECL_CONTEXT (decl) = basetype;
8880       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8881     }
8882   else
8883     {
8884       tree context;
8885
8886       if (in_namespace)
8887         context = in_namespace;
8888       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8889         context = current_namespace;
8890       else
8891         context = NULL_TREE;
8892
8893       if (processing_template_decl)
8894         /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8895            we can call push_template_decl.  */
8896         decl = build_lang_decl (VAR_DECL, declarator, type);
8897       else
8898         decl = build_decl (VAR_DECL, declarator, type);
8899
8900       if (context)
8901         set_decl_namespace (decl, context, 0);
8902
8903       context = DECL_CONTEXT (decl);
8904       if (declarator && context && current_lang_name != lang_name_c)
8905         DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8906     }
8907
8908   if (in_namespace)
8909     set_decl_namespace (decl, in_namespace, 0);
8910
8911   if (RIDBIT_SETP (RID_EXTERN, specbits))
8912     {
8913       DECL_THIS_EXTERN (decl) = 1;
8914       DECL_EXTERNAL (decl) = !initialized;
8915     }
8916
8917   /* In class context, static means one per class,
8918      public access, and static storage.  */
8919   if (DECL_CLASS_SCOPE_P (decl))
8920     {
8921       TREE_PUBLIC (decl) = 1;
8922       TREE_STATIC (decl) = 1;
8923       DECL_EXTERNAL (decl) = 0;
8924     }
8925   /* At top level, either `static' or no s.c. makes a definition
8926      (perhaps tentative), and absence of `static' makes it public.  */
8927   else if (toplevel_bindings_p ())
8928     {
8929       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8930                             && (DECL_THIS_EXTERN (decl) || ! constp));
8931       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8932     }
8933   /* Not at top level, only `static' makes a static definition.  */
8934   else
8935     {
8936       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8937       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8938     }
8939
8940   if (TREE_PUBLIC (decl))
8941     {
8942       /* [basic.link]: A name with no linkage (notably, the name of a class
8943          or enumeration declared in a local scope) shall not be used to
8944          declare an entity with linkage.
8945
8946          Only check this for public decls for now.  */
8947       tree t = no_linkage_check (TREE_TYPE (decl));
8948       if (t)
8949         {
8950           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8951             /* Ignore for now; `enum { foo } e' is pretty common.  */;
8952           else
8953             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8954                         decl, t);
8955         }
8956     }
8957
8958   return decl;
8959 }
8960
8961 /* Create and return a canonical pointer to member function type, for
8962    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
8963
8964 tree
8965 build_ptrmemfunc_type (type)
8966      tree type;
8967 {
8968   tree fields[4];
8969   tree t;
8970   tree u;
8971   tree unqualified_variant = NULL_TREE;
8972
8973   /* If a canonical type already exists for this type, use it.  We use
8974      this method instead of type_hash_canon, because it only does a
8975      simple equality check on the list of field members.  */
8976
8977   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8978     return t;
8979
8980   /* Make sure that we always have the unqualified pointer-to-member
8981      type first.  */
8982   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8983     unqualified_variant
8984       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
8985
8986   t = make_aggr_type (RECORD_TYPE);
8987   /* Let the front-end know this is a pointer to member function...  */
8988   TYPE_PTRMEMFUNC_FLAG (t) = 1;
8989   /* ... and not really an aggregate.  */
8990   SET_IS_AGGR_TYPE (t, 0);
8991
8992   if (!flag_new_abi)
8993     {
8994       u = make_aggr_type (UNION_TYPE);
8995       SET_IS_AGGR_TYPE (u, 0);
8996       fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
8997       fields[1] = build_lang_decl (FIELD_DECL, delta2_identifier,
8998                                    delta_type_node);
8999       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9000       TYPE_NAME (u) = NULL_TREE;
9001
9002       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
9003                                    delta_type_node);
9004       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
9005                                    delta_type_node);
9006       fields[2] = build_lang_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9007       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9008     }
9009   else
9010     {
9011       fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
9012       fields[1] = build_lang_decl (FIELD_DECL, delta_identifier,
9013                                    delta_type_node);
9014       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9015     }
9016
9017   /* Zap out the name so that the back-end will give us the debugging
9018      information for this anonymous RECORD_TYPE.  */
9019   TYPE_NAME (t) = NULL_TREE;
9020
9021   /* If this is not the unqualified form of this pointer-to-member
9022      type, set the TYPE_MAIN_VARIANT for this type to be the
9023      unqualified type.  Since they are actually RECORD_TYPEs that are
9024      not variants of each other, we must do this manually.  */
9025   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9026     {
9027       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9028       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9029       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9030       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9031     }
9032
9033   /* Cache this pointer-to-member type so that we can find it again
9034      later.  */
9035   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9036
9037   /* Seems to be wanted.  */
9038   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9039
9040   return t;
9041 }
9042
9043 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9044    Check to see that the definition is valid.  Issue appropriate error
9045    messages.  Return 1 if the definition is particularly bad, or 0
9046    otherwise.  */
9047
9048 int
9049 check_static_variable_definition (decl, type)
9050      tree decl;
9051      tree type;
9052 {
9053   /* Motion 10 at San Diego: If a static const integral data member is
9054      initialized with an integral constant expression, the initializer
9055      may appear either in the declaration (within the class), or in
9056      the definition, but not both.  If it appears in the class, the
9057      member is a member constant.  The file-scope definition is always
9058      required.  */
9059   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9060     {
9061       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9062                 type);
9063       /* If we just return the declaration, crashes will sometimes
9064          occur.  We therefore return void_type_node, as if this was a
9065          friend declaration, to cause callers to completely ignore
9066          this declaration.  */
9067       return 1;
9068     }
9069   else if (!CP_TYPE_CONST_P (type))
9070     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9071               decl);
9072   else if (pedantic && !INTEGRAL_TYPE_P (type))
9073     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9074
9075   return 0;
9076 }
9077
9078 /* Given the SIZE (i.e., number of elements) in an array, compute an
9079    appropriate index type for the array.  If non-NULL, NAME is the
9080    name of the thing being declared.  */
9081
9082 tree
9083 compute_array_index_type (name, size)
9084      tree name;
9085      tree size;
9086 {
9087   tree itype;
9088
9089   /* The size might be the result of a cast. */
9090   STRIP_TYPE_NOPS (size);
9091
9092   /* It might be a const variable or enumeration constant.  */
9093   if (TREE_READONLY_DECL_P (size))
9094     size = decl_constant_value (size);
9095
9096   /* If this involves a template parameter, it will be a constant at
9097      instantiation time, but we don't know what the value is yet.
9098      Even if no template parameters are involved, we may an expression
9099      that is not a constant; we don't even simplify `1 + 2' when
9100      processing a template.  */
9101   if (processing_template_decl)
9102     {
9103       /* Resolve a qualified reference to an enumerator or static
9104          const data member of ours.  */
9105       if (TREE_CODE (size) == SCOPE_REF
9106           && TREE_OPERAND (size, 0) == current_class_type)
9107         {
9108           tree t = lookup_field (current_class_type,
9109                                  TREE_OPERAND (size, 1), 0, 0);
9110           if (t)
9111             size = t;
9112         }
9113
9114       return build_index_type (build_min (MINUS_EXPR, sizetype,
9115                                           size, integer_one_node));
9116     }
9117
9118   /* The array bound must be an integer type.  */
9119   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9120       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9121       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9122     {
9123       if (name)
9124         cp_error ("size of array `%D' has non-integer type", name);
9125       else
9126         cp_error ("size of array has non-integer type");
9127       size = integer_one_node;
9128     }
9129
9130   /* Normally, the array-bound will be a constant.  */
9131   if (TREE_CONSTANT (size))
9132     {
9133       /* Check to see if the array bound overflowed.  Make that an
9134          error, no matter how generous we're being.  */
9135       int old_flag_pedantic_errors = flag_pedantic_errors;
9136       int old_pedantic = pedantic;
9137       pedantic = flag_pedantic_errors = 1;
9138       constant_expression_warning (size);
9139       pedantic = old_pedantic;
9140       flag_pedantic_errors = old_flag_pedantic_errors;
9141
9142       /* An array must have a positive number of elements.  */
9143       if (INT_CST_LT (size, integer_zero_node))
9144         {
9145           if (name)
9146             cp_error ("size of array `%D' is negative", name);
9147           else
9148             cp_error ("size of array is negative");
9149           size = integer_one_node;
9150         }
9151       /* Except that an extension we allow zero-sized arrays.  We
9152          always allow them in system headers because glibc uses
9153          them.  */
9154       else if (integer_zerop (size) && pedantic && !in_system_header)
9155         {
9156           if (name)
9157             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9158           else
9159             cp_pedwarn ("ISO C++ forbids zero-size array");
9160         }
9161     }
9162
9163   /* Compute the index of the largest element in the array.  It is
9164      one less than the number of elements in the array.  */
9165   itype
9166     = fold (build_binary_op (MINUS_EXPR,
9167                              cp_convert (ssizetype, size),
9168                              cp_convert (ssizetype,
9169                                          integer_one_node)));
9170
9171   /* Check for variable-sized arrays.  We allow such things as an
9172      extension, even though they are not allowed in ANSI/ISO C++.  */
9173   if (!TREE_CONSTANT (itype))
9174     {
9175       if (pedantic)
9176         {
9177           if (name)
9178             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9179                         name);
9180           else
9181             cp_pedwarn ("ISO C++ forbids variable-size array");
9182         }
9183
9184       /* Create a variable-sized array index type.  */
9185       itype = variable_size (itype);
9186     }
9187   /* Make sure that there was no overflow when creating to a signed
9188      index type.  (For example, on a 32-bit machine, an array with
9189      size 2^32 - 1 is too big.)  */
9190   else if (TREE_OVERFLOW (itype))
9191     {
9192       error ("overflow in array dimension");
9193       TREE_OVERFLOW (itype) = 0;
9194     }
9195
9196   /* Create and return the appropriate index type.  */
9197   return build_index_type (itype);
9198 }
9199
9200 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9201    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9202    with this type.  */
9203
9204 static tree
9205 create_array_type_for_decl (name, type, size)
9206      tree name;
9207      tree type;
9208      tree size;
9209 {
9210   tree itype = NULL_TREE;
9211   const char* error_msg;
9212
9213   /* If things have already gone awry, bail now.  */
9214   if (type == error_mark_node || size == error_mark_node)
9215     return error_mark_node;
9216
9217   /* Assume that everything will go OK.  */
9218   error_msg = NULL;
9219
9220   /* There are some types which cannot be array elements.  */
9221   switch (TREE_CODE (type))
9222     {
9223     case VOID_TYPE:
9224       error_msg = "array of void";
9225       break;
9226
9227     case FUNCTION_TYPE:
9228       error_msg = "array of functions";
9229       break;
9230
9231     case REFERENCE_TYPE:
9232       error_msg = "array of references";
9233       break;
9234
9235     case OFFSET_TYPE:
9236       error_msg = "array of data members";
9237       break;
9238
9239     case METHOD_TYPE:
9240       error_msg = "array of function members";
9241       break;
9242
9243     default:
9244       break;
9245     }
9246
9247   /* If something went wrong, issue an error-message and return.  */
9248   if (error_msg)
9249     {
9250       if (name)
9251         cp_error ("declaration of `%D' as %s", name, error_msg);
9252       else
9253         cp_error ("creating %s", error_msg);
9254
9255       return error_mark_node;
9256     }
9257
9258   /* [dcl.array]
9259
9260      The constant expressions that specify the bounds of the arrays
9261      can be omitted only for the first member of the sequence.  */
9262   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9263     {
9264       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9265                 name);
9266
9267       return error_mark_node;
9268     }
9269
9270   /* Figure out the index type for the array.  */
9271   if (size)
9272     itype = compute_array_index_type (name, size);
9273
9274   return build_cplus_array_type (type, itype);
9275 }
9276
9277 /* Given declspecs and a declarator,
9278    determine the name and type of the object declared
9279    and construct a ..._DECL node for it.
9280    (In one case we can return a ..._TYPE node instead.
9281     For invalid input we sometimes return 0.)
9282
9283    DECLSPECS is a chain of tree_list nodes whose value fields
9284     are the storage classes and type specifiers.
9285
9286    DECL_CONTEXT says which syntactic context this declaration is in:
9287      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9288      FUNCDEF for a function definition.  Like NORMAL but a few different
9289       error messages in each case.  Return value may be zero meaning
9290       this definition is too screwy to try to parse.
9291      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9292       handle member functions (which have FIELD context).
9293       Return value may be zero meaning this definition is too screwy to
9294       try to parse.
9295      PARM for a parameter declaration (either within a function prototype
9296       or before a function body).  Make a PARM_DECL, or return void_type_node.
9297      CATCHPARM for a parameter declaration before a catch clause.
9298      TYPENAME if for a typename (in a cast or sizeof).
9299       Don't make a DECL node; just return the ..._TYPE node.
9300      FIELD for a struct or union field; make a FIELD_DECL.
9301      BITFIELD for a field with specified width.
9302    INITIALIZED is 1 if the decl has an initializer.
9303
9304    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9305    normal attributes in TREE_PURPOSE, or NULL_TREE.
9306
9307    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9308    It may also be so in the PARM case, for a prototype where the
9309    argument type is specified but not the name.
9310
9311    This function is where the complicated C meanings of `static'
9312    and `extern' are interpreted.
9313
9314    For C++, if there is any monkey business to do, the function which
9315    calls this one must do it, i.e., prepending instance variables,
9316    renaming overloaded function names, etc.
9317
9318    Note that for this C++, it is an error to define a method within a class
9319    which does not belong to that class.
9320
9321    Except in the case where SCOPE_REFs are implicitly known (such as
9322    methods within a class being redundantly qualified),
9323    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9324    (class_name::decl_name).  The caller must also deal with this.
9325
9326    If a constructor or destructor is seen, and the context is FIELD,
9327    then the type gains the attribute TREE_HAS_x.  If such a declaration
9328    is erroneous, NULL_TREE is returned.
9329
9330    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9331    function, these are the qualifiers to give to the `this' pointer. We
9332    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9333
9334    May return void_type_node if the declarator turned out to be a friend.
9335    See grokfield for details.  */
9336
9337 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
9338
9339 tree
9340 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9341      tree declspecs;
9342      tree declarator;
9343      enum decl_context decl_context;
9344      int initialized;
9345      tree attrlist;
9346 {
9347   RID_BIT_TYPE specbits;
9348   int nclasses = 0;
9349   tree spec;
9350   tree type = NULL_TREE;
9351   int longlong = 0;
9352   int constp;
9353   int restrictp;
9354   int volatilep;
9355   int type_quals;
9356   int virtualp, explicitp, friendp, inlinep, staticp;
9357   int explicit_int = 0;
9358   int explicit_char = 0;
9359   int defaulted_int = 0;
9360   tree typedef_decl = NULL_TREE;
9361   const char *name;
9362   tree typedef_type = NULL_TREE;
9363   int funcdef_flag = 0;
9364   enum tree_code innermost_code = ERROR_MARK;
9365   int bitfield = 0;
9366 #if 0
9367   /* See the code below that used this.  */
9368   tree decl_machine_attr = NULL_TREE;
9369 #endif
9370   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9371      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9372   tree init = NULL_TREE;
9373
9374   /* Keep track of what sort of function is being processed
9375      so that we can warn about default return values, or explicit
9376      return values which do not match prescribed defaults.  */
9377   enum return_types return_type = return_normal;
9378
9379   tree dname = NULL_TREE;
9380   tree ctype = current_class_type;
9381   tree ctor_return_type = NULL_TREE;
9382   enum overload_flags flags = NO_SPECIAL;
9383   tree quals = NULL_TREE;
9384   tree raises = NULL_TREE;
9385   int template_count = 0;
9386   tree in_namespace = NULL_TREE;
9387   tree inner_attrs;
9388   int ignore_attrs;
9389
9390   RIDBIT_RESET_ALL (specbits);
9391   if (decl_context == FUNCDEF)
9392     funcdef_flag = 1, decl_context = NORMAL;
9393   else if (decl_context == MEMFUNCDEF)
9394     funcdef_flag = -1, decl_context = FIELD;
9395   else if (decl_context == BITFIELD)
9396     bitfield = 1, decl_context = FIELD;
9397
9398   /* Look inside a declarator for the name being declared
9399      and get it as a string, for an error message.  */
9400   {
9401     tree *next = &declarator;
9402     register tree decl;
9403     name = NULL;
9404
9405     while (next && *next)
9406       {
9407         decl = *next;
9408         switch (TREE_CODE (decl))
9409           {
9410           case TREE_LIST:
9411             /* For attributes.  */
9412             next = &TREE_VALUE (decl);
9413             break;
9414
9415           case COND_EXPR:
9416             ctype = NULL_TREE;
9417             next = &TREE_OPERAND (decl, 0);
9418             break;
9419
9420           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9421             {
9422               tree name = TREE_OPERAND (decl, 0);
9423               tree rename = NULL_TREE;
9424
9425               my_friendly_assert (flags == NO_SPECIAL, 152);
9426               flags = DTOR_FLAG;
9427               return_type = return_dtor;
9428               if (TREE_CODE (name) == TYPE_DECL)
9429                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9430               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9431               if (ctype == NULL_TREE)
9432                 {
9433                   if (current_class_type == NULL_TREE)
9434                     {
9435                       error ("destructors must be member functions");
9436                       flags = NO_SPECIAL;
9437                     }
9438                   else
9439                     {
9440                       tree t = constructor_name (current_class_name);
9441                       if (t != name)
9442                         rename = t;
9443                     }
9444                 }
9445               else
9446                 {
9447                   tree t = constructor_name (ctype);
9448                   if (t != name)
9449                     rename = t;
9450                 }
9451
9452               if (rename)
9453                 {
9454                   cp_error ("destructor `%T' must match class name `%T'",
9455                             name, rename);
9456                   TREE_OPERAND (decl, 0) = rename;
9457                 }
9458               next = &name;
9459             }
9460             break;
9461
9462           case ADDR_EXPR:       /* C++ reference declaration */
9463             /* Fall through. */
9464           case ARRAY_REF:
9465           case INDIRECT_REF:
9466             ctype = NULL_TREE;
9467             innermost_code = TREE_CODE (decl);
9468             next = &TREE_OPERAND (decl, 0);
9469             break;
9470
9471           case CALL_EXPR:
9472             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9473               {
9474                 /* This is actually a variable declaration using
9475                    constructor syntax.  We need to call start_decl and
9476                    cp_finish_decl so we can get the variable
9477                    initialized...  */
9478
9479                 tree attributes, prefix_attributes;
9480
9481                 *next = TREE_OPERAND (decl, 0);
9482                 init = CALL_DECLARATOR_PARMS (decl);
9483
9484                 if (attrlist)
9485                   {
9486                     attributes = TREE_PURPOSE (attrlist);
9487                     prefix_attributes = TREE_VALUE (attrlist);
9488                   }
9489                 else
9490                   {
9491                     attributes = NULL_TREE;
9492                     prefix_attributes = NULL_TREE;
9493                   }
9494
9495                 decl = start_decl (declarator, declspecs, 1,
9496                                    attributes, prefix_attributes);
9497                 decl_type_access_control (decl);
9498                 if (decl)
9499                   {
9500                     /* Look for __unused__ attribute */
9501                     if (TREE_USED (TREE_TYPE (decl)))
9502                       TREE_USED (decl) = 1;
9503                     finish_decl (decl, init, NULL_TREE);
9504                   }
9505                 else
9506                   cp_error ("invalid declarator");
9507                 return 0;
9508               }
9509             innermost_code = TREE_CODE (decl);
9510             if (decl_context == FIELD && ctype == NULL_TREE)
9511               ctype = current_class_type;
9512             if (ctype
9513                 && TREE_OPERAND (decl, 0)
9514                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9515                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9516                          == constructor_name_full (ctype))
9517                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9518                             == constructor_name (ctype)))))
9519               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9520             next = &TREE_OPERAND (decl, 0);
9521             decl = *next;
9522             if (ctype != NULL_TREE
9523                 && decl != NULL_TREE && flags != DTOR_FLAG
9524                 && decl == constructor_name (ctype))
9525               {
9526                 return_type = return_ctor;
9527                 ctor_return_type = ctype;
9528               }
9529             ctype = NULL_TREE;
9530             break;
9531
9532           case TEMPLATE_ID_EXPR:
9533               {
9534                 tree fns = TREE_OPERAND (decl, 0);
9535
9536                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9537                   fns = TREE_OPERAND (fns, 0);
9538
9539                 dname = fns;
9540                 if (TREE_CODE (dname) == COMPONENT_REF)
9541                   dname = TREE_OPERAND (dname, 1);
9542                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9543                   {
9544                     my_friendly_assert (is_overloaded_fn (dname),
9545                                         19990331);
9546                     dname = DECL_NAME (get_first_fn (dname));
9547                   }
9548               }
9549           /* Fall through. */
9550
9551           case IDENTIFIER_NODE:
9552             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9553               dname = decl;
9554
9555             next = 0;
9556
9557             if (is_rid (dname))
9558               {
9559                 cp_error ("declarator-id missing; using reserved word `%D'",
9560                           dname);
9561                 name = IDENTIFIER_POINTER (dname);
9562               }
9563             if (! IDENTIFIER_OPNAME_P (dname)
9564                 /* GNU/Linux headers use '__op'.  Arrgh.  */
9565                 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
9566               name = IDENTIFIER_POINTER (dname);
9567             else
9568               {
9569                 if (IDENTIFIER_TYPENAME_P (dname))
9570                   {
9571                     my_friendly_assert (flags == NO_SPECIAL, 154);
9572                     flags = TYPENAME_FLAG;
9573                     ctor_return_type = TREE_TYPE (dname);
9574                     return_type = return_conversion;
9575                   }
9576                 name = operator_name_string (dname);
9577               }
9578             break;
9579
9580             /* C++ extension */
9581           case SCOPE_REF:
9582             {
9583               /* Perform error checking, and decide on a ctype.  */
9584               tree cname = TREE_OPERAND (decl, 0);
9585               if (cname == NULL_TREE)
9586                 ctype = NULL_TREE;
9587               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9588                 {
9589                   ctype = NULL_TREE;
9590                   in_namespace = TREE_OPERAND (decl, 0);
9591                   TREE_OPERAND (decl, 0) = NULL_TREE;
9592                 }
9593               else if (! is_aggr_type (cname, 1))
9594                 TREE_OPERAND (decl, 0) = NULL_TREE;
9595               /* Must test TREE_OPERAND (decl, 1), in case user gives
9596                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9597               else if (TREE_OPERAND (decl, 1)
9598                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9599                 ctype = cname;
9600               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9601                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9602                 {
9603                   cp_error ("`%T::%D' is not a valid declarator", cname,
9604                             TREE_OPERAND (decl, 1));
9605                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9606                             cname, TREE_OPERAND (decl, 1));
9607                   return void_type_node;
9608                 }
9609               else if (ctype == NULL_TREE)
9610                 ctype = cname;
9611               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9612                 TREE_OPERAND (decl, 0) = ctype;
9613               else
9614                 {
9615                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9616                     {
9617                       cp_error ("type `%T' is not derived from type `%T'",
9618                                 cname, ctype);
9619                       TREE_OPERAND (decl, 0) = NULL_TREE;
9620                     }
9621                   else
9622                     ctype = cname;
9623                 }
9624
9625               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9626                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9627                        == constructor_name_full (ctype))
9628                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9629                           == constructor_name (ctype))))
9630                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9631               next = &TREE_OPERAND (decl, 1);
9632               decl = *next;
9633               if (ctype)
9634                 {
9635                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9636                       && constructor_name (ctype) == decl)
9637                     {
9638                       return_type = return_ctor;
9639                       ctor_return_type = ctype;
9640                     }
9641                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9642                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9643                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9644                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9645                     {
9646                       return_type = return_dtor;
9647                       ctor_return_type = ctype;
9648                       flags = DTOR_FLAG;
9649                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9650                       next = &TREE_OPERAND (decl, 0);
9651                     }
9652                 }
9653             }
9654             break;
9655
9656           case ERROR_MARK:
9657             next = 0;
9658             break;
9659
9660           case TYPE_DECL:
9661             /* Parse error puts this typespec where
9662                a declarator should go.  */
9663             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9664             if (TREE_TYPE (decl) == current_class_type)
9665               cp_error ("  perhaps you want `%T' for a constructor",
9666                         current_class_name);
9667             dname = DECL_NAME (decl);
9668             name = IDENTIFIER_POINTER (dname);
9669
9670             /* Avoid giving two errors for this.  */
9671             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9672
9673             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9674             *next = dname;
9675             next = 0;
9676             break;
9677
9678           default:
9679             cp_compiler_error ("`%D' as declarator", decl);
9680             return 0; /* We used to do a 155 abort here.  */
9681           }
9682       }
9683   }
9684
9685   /* A function definition's declarator must have the form of
9686      a function declarator.  */
9687
9688   if (funcdef_flag && innermost_code != CALL_EXPR)
9689     return 0;
9690
9691   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9692       && innermost_code != CALL_EXPR
9693       && ! (ctype && declspecs == NULL_TREE))
9694     {
9695       cp_error ("declaration of `%D' as non-function", dname);
9696       return void_type_node;
9697     }
9698
9699   /* Anything declared one level down from the top level
9700      must be one of the parameters of a function
9701      (because the body is at least two levels down).  */
9702
9703   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9704      by not allowing C++ class definitions to specify their parameters
9705      with xdecls (must be spec.d in the parmlist).
9706
9707      Since we now wait to push a class scope until we are sure that
9708      we are in a legitimate method context, we must set oldcname
9709      explicitly (since current_class_name is not yet alive).
9710
9711      We also want to avoid calling this a PARM if it is in a namespace.  */
9712
9713   if (decl_context == NORMAL && !toplevel_bindings_p ())
9714     {
9715       struct binding_level *b = current_binding_level;
9716       current_binding_level = b->level_chain;
9717       if (current_binding_level != 0 && toplevel_bindings_p ())
9718         decl_context = PARM;
9719       current_binding_level = b;
9720     }
9721
9722   if (name == NULL)
9723     name = decl_context == PARM ? "parameter" : "type name";
9724
9725   /* Look through the decl specs and record which ones appear.
9726      Some typespecs are defined as built-in typenames.
9727      Others, the ones that are modifiers of other types,
9728      are represented by bits in SPECBITS: set the bits for
9729      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9730
9731      If there is a typedef name or a type, store the type in TYPE.
9732      This includes builtin typedefs such as `int'.
9733
9734      Set EXPLICIT_INT if the type is `int' or `char' and did not
9735      come from a user typedef.
9736
9737      Set LONGLONG if `long' is mentioned twice.
9738
9739      For C++, constructors and destructors have their own fast treatment.  */
9740
9741   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9742     {
9743       register int i;
9744       register tree id;
9745
9746       /* Certain parse errors slip through.  For example,
9747          `int class;' is not caught by the parser. Try
9748          weakly to recover here.  */
9749       if (TREE_CODE (spec) != TREE_LIST)
9750         return 0;
9751
9752       id = TREE_VALUE (spec);
9753
9754       if (TREE_CODE (id) == IDENTIFIER_NODE)
9755         {
9756           if (id == ridpointers[(int) RID_INT]
9757               || id == ridpointers[(int) RID_CHAR]
9758               || id == ridpointers[(int) RID_BOOL]
9759               || id == ridpointers[(int) RID_WCHAR])
9760             {
9761               if (type)
9762                 {
9763                   if (id == ridpointers[(int) RID_BOOL])
9764                     error ("`bool' is now a keyword");
9765                   else
9766                     cp_error ("extraneous `%T' ignored", id);
9767                 }
9768               else
9769                 {
9770                   if (id == ridpointers[(int) RID_INT])
9771                     explicit_int = 1;
9772                   else if (id == ridpointers[(int) RID_CHAR])
9773                     explicit_char = 1;
9774                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9775                 }
9776               goto found;
9777             }
9778           /* C++ aggregate types.  */
9779           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9780             {
9781               if (type)
9782                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9783               else
9784                 type = IDENTIFIER_TYPE_VALUE (id);
9785               goto found;
9786             }
9787
9788           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9789             {
9790               if (ridpointers[i] == id)
9791                 {
9792                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9793                     {
9794                       if (pedantic && ! in_system_header && warn_long_long)
9795                         pedwarn ("ISO C++ does not support `long long'");
9796                       if (longlong)
9797                         error ("`long long long' is too long for GCC");
9798                       else
9799                         longlong = 1;
9800                     }
9801                   else if (RIDBIT_SETP (i, specbits))
9802                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9803                   RIDBIT_SET (i, specbits);
9804                   goto found;
9805                 }
9806             }
9807         }
9808       /* C++ aggregate types.  */
9809       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9810         {
9811           if (type)
9812             cp_error ("multiple declarations `%T' and `%T'", type,
9813                       TREE_TYPE (id));
9814           else
9815             {
9816               type = TREE_TYPE (id);
9817               TREE_VALUE (spec) = type;
9818             }
9819           goto found;
9820         }
9821       if (type)
9822         error ("two or more data types in declaration of `%s'", name);
9823       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9824         {
9825           register tree t = lookup_name (id, 1);
9826           if (!t || TREE_CODE (t) != TYPE_DECL)
9827             error ("`%s' fails to be a typedef or built in type",
9828                    IDENTIFIER_POINTER (id));
9829           else
9830             {
9831               type = TREE_TYPE (t);
9832 #if 0
9833               /* See the code below that used this.  */
9834               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9835 #endif
9836               typedef_decl = t;
9837             }
9838         }
9839       else if (id != error_mark_node)
9840         /* Can't change CLASS nodes into RECORD nodes here!  */
9841         type = id;
9842
9843     found: ;
9844     }
9845
9846   typedef_type = type;
9847
9848   /* No type at all: default to `int', and set DEFAULTED_INT
9849      because it was not a user-defined typedef.  */
9850
9851   if (type == NULL_TREE
9852       && (RIDBIT_SETP (RID_SIGNED, specbits)
9853           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9854           || RIDBIT_SETP (RID_LONG, specbits)
9855           || RIDBIT_SETP (RID_SHORT, specbits)))
9856     {
9857       /* These imply 'int'.  */
9858       type = integer_type_node;
9859       defaulted_int = 1;
9860     }
9861
9862   if (type == NULL_TREE)
9863     {
9864       explicit_int = -1;
9865       if (return_type == return_dtor)
9866         type = void_type_node;
9867       else if (return_type == return_ctor)
9868         type = build_pointer_type (ctor_return_type);
9869       else if (return_type == return_conversion)
9870         type = ctor_return_type;
9871       else
9872         {
9873           /* We handle `main' specially here, because 'main () { }' is so
9874              common.  With no options, it is allowed.  With -Wreturn-type,
9875              it is a warning.  It is only an error with -pedantic-errors.  */
9876           int is_main = (funcdef_flag
9877                          && MAIN_NAME_P (dname)
9878                          && ctype == NULL_TREE
9879                          && in_namespace == NULL_TREE
9880                          && current_namespace == global_namespace);
9881
9882           if (in_system_header || flag_ms_extensions)
9883             /* Allow it, sigh.  */;
9884           else if (pedantic || ! is_main)
9885             cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
9886                         name);
9887           else if (warn_return_type)
9888             cp_warning ("ISO C++ forbids declaration of `%s' with no type",
9889                         name);
9890
9891           type = integer_type_node;
9892         }
9893     }
9894   else if (return_type == return_dtor)
9895     {
9896       error ("return type specification for destructor invalid");
9897       type = void_type_node;
9898     }
9899   else if (return_type == return_ctor)
9900     {
9901       error ("return type specification for constructor invalid");
9902       type = build_pointer_type (ctor_return_type);
9903     }
9904   else if (return_type == return_conversion)
9905     {
9906       if (!same_type_p (type, ctor_return_type))
9907         cp_error ("operator `%T' declared to return `%T'",
9908                   ctor_return_type, type);
9909       else
9910         cp_pedwarn ("return type specified for `operator %T'",
9911                     ctor_return_type);
9912
9913       type = ctor_return_type;
9914     }
9915
9916   ctype = NULL_TREE;
9917
9918   /* Now process the modifiers that were specified
9919      and check for invalid combinations.  */
9920
9921   /* Long double is a special combination.  */
9922
9923   if (RIDBIT_SETP (RID_LONG, specbits)
9924       && TYPE_MAIN_VARIANT (type) == double_type_node)
9925     {
9926       RIDBIT_RESET (RID_LONG, specbits);
9927       type = build_qualified_type (long_double_type_node,
9928                                    CP_TYPE_QUALS (type));
9929     }
9930
9931   /* Check all other uses of type modifiers.  */
9932
9933   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9934       || RIDBIT_SETP (RID_SIGNED, specbits)
9935       || RIDBIT_SETP (RID_LONG, specbits)
9936       || RIDBIT_SETP (RID_SHORT, specbits))
9937     {
9938       int ok = 0;
9939
9940       if (TREE_CODE (type) == REAL_TYPE)
9941         error ("short, signed or unsigned invalid for `%s'", name);
9942       else if (TREE_CODE (type) != INTEGER_TYPE)
9943         error ("long, short, signed or unsigned invalid for `%s'", name);
9944       else if (RIDBIT_SETP (RID_LONG, specbits)
9945                && RIDBIT_SETP (RID_SHORT, specbits))
9946         error ("long and short specified together for `%s'", name);
9947       else if ((RIDBIT_SETP (RID_LONG, specbits)
9948                 || RIDBIT_SETP (RID_SHORT, specbits))
9949                && explicit_char)
9950         error ("long or short specified with char for `%s'", name);
9951       else if ((RIDBIT_SETP (RID_LONG, specbits)
9952                 || RIDBIT_SETP (RID_SHORT, specbits))
9953                && TREE_CODE (type) == REAL_TYPE)
9954         error ("long or short specified with floating type for `%s'", name);
9955       else if (RIDBIT_SETP (RID_SIGNED, specbits)
9956                && RIDBIT_SETP (RID_UNSIGNED, specbits))
9957         error ("signed and unsigned given together for `%s'", name);
9958       else
9959         {
9960           ok = 1;
9961           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
9962             {
9963               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9964                        name);
9965               if (flag_pedantic_errors)
9966                 ok = 0;
9967             }
9968         }
9969
9970       /* Discard the type modifiers if they are invalid.  */
9971       if (! ok)
9972         {
9973           RIDBIT_RESET (RID_UNSIGNED, specbits);
9974           RIDBIT_RESET (RID_SIGNED, specbits);
9975           RIDBIT_RESET (RID_LONG, specbits);
9976           RIDBIT_RESET (RID_SHORT, specbits);
9977           longlong = 0;
9978         }
9979     }
9980
9981   if (RIDBIT_SETP (RID_COMPLEX, specbits)
9982       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9983     {
9984       error ("complex invalid for `%s'", name);
9985       RIDBIT_RESET (RID_COMPLEX, specbits);
9986     }
9987
9988   /* Decide whether an integer type is signed or not.
9989      Optionally treat bitfields as signed by default.  */
9990   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9991       /* [class.bit]
9992
9993          It is implementation-defined whether a plain (neither
9994          explicitly signed or unsigned) char, short, int, or long
9995          bit-field is signed or unsigned.
9996
9997          Naturally, we extend this to long long as well.  Note that
9998          this does not include wchar_t.  */
9999       || (bitfield && !flag_signed_bitfields
10000           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10001           /* A typedef for plain `int' without `signed' can be
10002              controlled just like plain `int', but a typedef for
10003              `signed int' cannot be so controlled.  */
10004           && !(typedef_decl
10005                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10006           && (TREE_CODE (type) == INTEGER_TYPE
10007               || TREE_CODE (type) == CHAR_TYPE)
10008           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10009     {
10010       if (longlong)
10011         type = long_long_unsigned_type_node;
10012       else if (RIDBIT_SETP (RID_LONG, specbits))
10013         type = long_unsigned_type_node;
10014       else if (RIDBIT_SETP (RID_SHORT, specbits))
10015         type = short_unsigned_type_node;
10016       else if (type == char_type_node)
10017         type = unsigned_char_type_node;
10018       else if (typedef_decl)
10019         type = unsigned_type (type);
10020       else
10021         type = unsigned_type_node;
10022     }
10023   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10024            && type == char_type_node)
10025     type = signed_char_type_node;
10026   else if (longlong)
10027     type = long_long_integer_type_node;
10028   else if (RIDBIT_SETP (RID_LONG, specbits))
10029     type = long_integer_type_node;
10030   else if (RIDBIT_SETP (RID_SHORT, specbits))
10031     type = short_integer_type_node;
10032
10033   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10034     {
10035       /* If we just have "complex", it is equivalent to
10036          "complex double", but if any modifiers at all are specified it is
10037          the complex form of TYPE.  E.g, "complex short" is
10038          "complex short int".  */
10039
10040       if (defaulted_int && ! longlong
10041           && ! (RIDBIT_SETP (RID_LONG, specbits)
10042                 || RIDBIT_SETP (RID_SHORT, specbits)
10043                 || RIDBIT_SETP (RID_SIGNED, specbits)
10044                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10045         type = complex_double_type_node;
10046       else if (type == integer_type_node)
10047         type = complex_integer_type_node;
10048       else if (type == float_type_node)
10049         type = complex_float_type_node;
10050       else if (type == double_type_node)
10051         type = complex_double_type_node;
10052       else if (type == long_double_type_node)
10053         type = complex_long_double_type_node;
10054       else
10055         type = build_complex_type (type);
10056     }
10057
10058   if (return_type == return_conversion
10059       && (RIDBIT_SETP (RID_CONST, specbits)
10060           || RIDBIT_SETP (RID_VOLATILE, specbits)
10061           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10062     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10063               ctor_return_type);
10064
10065   /* Set CONSTP if this declaration is `const', whether by
10066      explicit specification or via a typedef.
10067      Likewise for VOLATILEP.  */
10068
10069   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10070   restrictp =
10071     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10072   volatilep =
10073     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10074   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10075                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10076                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10077   type = cp_build_qualified_type (type, type_quals);
10078   staticp = 0;
10079   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10080   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10081   RIDBIT_RESET (RID_VIRTUAL, specbits);
10082   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10083   RIDBIT_RESET (RID_EXPLICIT, specbits);
10084
10085   if (RIDBIT_SETP (RID_STATIC, specbits))
10086     staticp = 1 + (decl_context == FIELD);
10087
10088   if (virtualp && staticp == 2)
10089     {
10090       cp_error ("member `%D' cannot be declared both virtual and static",
10091                 dname);
10092       staticp = 0;
10093     }
10094   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10095   RIDBIT_RESET (RID_FRIEND, specbits);
10096
10097   /* Warn if two storage classes are given. Default to `auto'.  */
10098
10099   if (RIDBIT_ANY_SET (specbits))
10100     {
10101       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10102       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10103       if (decl_context == PARM && nclasses > 0)
10104         error ("storage class specifiers invalid in parameter declarations");
10105       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10106         {
10107           if (decl_context == PARM)
10108             error ("typedef declaration invalid in parameter declaration");
10109           nclasses++;
10110         }
10111       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10112       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10113     }
10114
10115   /* Give error if `virtual' is used outside of class declaration.  */
10116   if (virtualp
10117       && (current_class_name == NULL_TREE || decl_context != FIELD))
10118     {
10119       error ("virtual outside class declaration");
10120       virtualp = 0;
10121     }
10122
10123   /* Static anonymous unions are dealt with here.  */
10124   if (staticp && decl_context == TYPENAME
10125       && TREE_CODE (declspecs) == TREE_LIST
10126       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10127     decl_context = FIELD;
10128
10129   /* Warn about storage classes that are invalid for certain
10130      kinds of declarations (parameters, typenames, etc.).  */
10131
10132   if (nclasses > 1)
10133     error ("multiple storage classes in declaration of `%s'", name);
10134   else if (decl_context != NORMAL && nclasses > 0)
10135     {
10136       if ((decl_context == PARM || decl_context == CATCHPARM)
10137           && (RIDBIT_SETP (RID_REGISTER, specbits)
10138               || RIDBIT_SETP (RID_AUTO, specbits)))
10139         ;
10140       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10141         ;
10142       else if (decl_context == FIELD
10143                /* C++ allows static class elements  */
10144                && RIDBIT_SETP (RID_STATIC, specbits))
10145         /* C++ also allows inlines and signed and unsigned elements,
10146            but in those cases we don't come in here.  */
10147         ;
10148       else
10149         {
10150           if (decl_context == FIELD)
10151             {
10152               tree tmp = NULL_TREE;
10153               register int op = 0;
10154
10155               if (declarator)
10156                 {
10157                   /* Avoid trying to get an operand off an identifier node.  */
10158                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10159                     tmp = declarator;
10160                   else
10161                     tmp = TREE_OPERAND (declarator, 0);
10162                   op = IDENTIFIER_OPNAME_P (tmp);
10163                 }
10164               error ("storage class specified for %s `%s'",
10165                      op ? "member operator" : "field",
10166                      op ? operator_name_string (tmp) : name);
10167             }
10168           else
10169             {
10170               if (decl_context == PARM || decl_context == CATCHPARM)
10171                 error ("storage class specified for parameter `%s'", name);
10172               else
10173                 error ("storage class specified for typename");
10174             }
10175           RIDBIT_RESET (RID_REGISTER, specbits);
10176           RIDBIT_RESET (RID_AUTO, specbits);
10177           RIDBIT_RESET (RID_EXTERN, specbits);
10178         }
10179     }
10180   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10181     {
10182       if (toplevel_bindings_p ())
10183         {
10184           /* It's common practice (and completely valid) to have a const
10185              be initialized and declared extern.  */
10186           if (!(type_quals & TYPE_QUAL_CONST))
10187             warning ("`%s' initialized and declared `extern'", name);
10188         }
10189       else
10190         error ("`%s' has both `extern' and initializer", name);
10191     }
10192   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10193            && ! toplevel_bindings_p ())
10194     error ("nested function `%s' declared `extern'", name);
10195   else if (toplevel_bindings_p ())
10196     {
10197       if (RIDBIT_SETP (RID_AUTO, specbits))
10198         error ("top-level declaration of `%s' specifies `auto'", name);
10199     }
10200
10201   if (nclasses > 0 && friendp)
10202     error ("storage class specifiers invalid in friend function declarations");
10203
10204   /* Now figure out the structure of the declarator proper.
10205      Descend through it, creating more complex types, until we reach
10206      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10207
10208   inner_attrs = NULL_TREE;
10209   ignore_attrs = 0;
10210
10211   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10212          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10213     {
10214       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10215          an INDIRECT_REF (for *...),
10216          a CALL_EXPR (for ...(...)),
10217          an identifier (for the name being declared)
10218          or a null pointer (for the place in an absolute declarator
10219          where the name was omitted).
10220          For the last two cases, we have just exited the loop.
10221
10222          For C++ it could also be
10223          a SCOPE_REF (for class :: ...).  In this case, we have converted
10224          sensible names to types, and those are the values we use to
10225          qualify the member name.
10226          an ADDR_EXPR (for &...),
10227          a BIT_NOT_EXPR (for destructors)
10228
10229          At this point, TYPE is the type of elements of an array,
10230          or for a function to return, or for a pointer to point to.
10231          After this sequence of ifs, TYPE is the type of the
10232          array or function or pointer, and DECLARATOR has had its
10233          outermost layer removed.  */
10234
10235       if (type == error_mark_node)
10236         {
10237           if (TREE_CODE (declarator) == SCOPE_REF)
10238             declarator = TREE_OPERAND (declarator, 1);
10239           else
10240             declarator = TREE_OPERAND (declarator, 0);
10241           continue;
10242         }
10243       if (quals != NULL_TREE
10244           && (declarator == NULL_TREE
10245               || TREE_CODE (declarator) != SCOPE_REF))
10246         {
10247           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10248             ctype = TYPE_METHOD_BASETYPE (type);
10249           if (ctype != NULL_TREE)
10250             {
10251               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10252               grok_method_quals (ctype, dummy, quals);
10253               type = TREE_TYPE (dummy);
10254               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10255               quals = NULL_TREE;
10256             }
10257         }
10258
10259       /* See the comment for the TREE_LIST case, below.  */
10260       if (ignore_attrs)
10261         ignore_attrs = 0;
10262       else if (inner_attrs)
10263         {
10264           decl_attributes (type, inner_attrs, NULL_TREE);
10265           inner_attrs = NULL_TREE;
10266         }
10267
10268       switch (TREE_CODE (declarator))
10269         {
10270         case TREE_LIST:
10271           {
10272             /* We encode a declarator with embedded attributes using
10273                a TREE_LIST.  The attributes apply to the declarator
10274                directly inside them, so we have to skip an iteration
10275                before applying them to the type.  If the declarator just
10276                inside is the declarator-id, we apply the attrs to the
10277                decl itself.  */
10278             inner_attrs = TREE_PURPOSE (declarator);
10279             ignore_attrs = 1;
10280             declarator = TREE_VALUE (declarator);
10281           }
10282           break;
10283
10284         case ARRAY_REF:
10285           {
10286             register tree size;
10287
10288             size = TREE_OPERAND (declarator, 1);
10289
10290             /* VC++ spells a zero-sized array with [].  */
10291             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10292                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10293               size = integer_zero_node;
10294
10295             declarator = TREE_OPERAND (declarator, 0);
10296
10297             type = create_array_type_for_decl (dname, type, size);
10298             ctype = NULL_TREE;
10299           }
10300           break;
10301
10302         case CALL_EXPR:
10303           {
10304             tree arg_types;
10305             int funcdecl_p;
10306             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10307             tree inner_decl = TREE_OPERAND (declarator, 0);
10308
10309             /* Declaring a function type.
10310                Make sure we have a valid type for the function to return.  */
10311
10312             /* We now know that the TYPE_QUALS don't apply to the
10313                decl, but to its return type.  */
10314             type_quals = TYPE_UNQUALIFIED;
10315
10316             /* Warn about some types functions can't return.  */
10317
10318             if (TREE_CODE (type) == FUNCTION_TYPE)
10319               {
10320                 error ("`%s' declared as function returning a function", name);
10321                 type = integer_type_node;
10322               }
10323             if (TREE_CODE (type) == ARRAY_TYPE)
10324               {
10325                 error ("`%s' declared as function returning an array", name);
10326                 type = integer_type_node;
10327               }
10328
10329             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10330               inner_decl = TREE_OPERAND (inner_decl, 1);
10331
10332             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10333               inner_decl = dname;
10334
10335             /* Pick up type qualifiers which should be applied to `this'.  */
10336             quals = CALL_DECLARATOR_QUALS (declarator);
10337
10338             /* Pick up the exception specifications.  */
10339             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10340
10341             /* Say it's a definition only for the CALL_EXPR
10342                closest to the identifier.  */
10343             funcdecl_p
10344               = inner_decl
10345               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10346                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10347                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10348
10349             if (ctype == NULL_TREE
10350                 && decl_context == FIELD
10351                 && funcdecl_p
10352                 && (friendp == 0 || dname == current_class_name))
10353               ctype = current_class_type;
10354
10355             if (ctype && return_type == return_conversion)
10356               TYPE_HAS_CONVERSION (ctype) = 1;
10357             if (ctype && constructor_name (ctype) == dname)
10358               {
10359                 /* We are within a class's scope. If our declarator name
10360                    is the same as the class name, and we are defining
10361                    a function, then it is a constructor/destructor, and
10362                    therefore returns a void type.  */
10363
10364                 if (flags == DTOR_FLAG)
10365                   {
10366                     /* ISO C++ 12.4/2.  A destructor may not be
10367                        declared const or volatile.  A destructor may
10368                        not be static.  */
10369                     if (staticp == 2)
10370                       error ("destructor cannot be static member function");
10371                     if (quals)
10372                       {
10373                         cp_error ("destructors may not be `%s'",
10374                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10375                         quals = NULL_TREE;
10376                       }
10377                     if (decl_context == FIELD)
10378                       {
10379                         if (! member_function_or_else (ctype,
10380                                                        current_class_type,
10381                                                        flags))
10382                           return void_type_node;
10383                       }
10384                   }
10385                 else            /* It's a constructor.  */
10386                   {
10387                     if (explicitp == 1)
10388                       explicitp = 2;
10389                     /* ISO C++ 12.1.  A constructor may not be
10390                        declared const or volatile.  A constructor may
10391                        not be virtual.  A constructor may not be
10392                        static.  */
10393                     if (staticp == 2)
10394                       error ("constructor cannot be static member function");
10395                     if (virtualp)
10396                       {
10397                         pedwarn ("constructors cannot be declared virtual");
10398                         virtualp = 0;
10399                       }
10400                     if (quals)
10401                       {
10402                         cp_error ("constructors may not be `%s'",
10403                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10404                         quals = NULL_TREE;
10405                       }
10406                     {
10407                       RID_BIT_TYPE tmp_bits;
10408                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10409                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10410                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10411                       if (RIDBIT_ANY_SET (tmp_bits))
10412                         error ("return value type specifier for constructor ignored");
10413                     }
10414                     type = build_pointer_type (ctype);
10415                     if (decl_context == FIELD)
10416                       {
10417                         if (! member_function_or_else (ctype,
10418                                                        current_class_type,
10419                                                        flags))
10420                           return void_type_node;
10421                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10422                         if (return_type != return_ctor)
10423                           return NULL_TREE;
10424                       }
10425                   }
10426                 if (decl_context == FIELD)
10427                   staticp = 0;
10428               }
10429             else if (friendp)
10430               {
10431                 if (initialized)
10432                   error ("can't initialize friend function `%s'", name);
10433                 if (virtualp)
10434                   {
10435                     /* Cannot be both friend and virtual.  */
10436                     error ("virtual functions cannot be friends");
10437                     RIDBIT_RESET (RID_FRIEND, specbits);
10438                     friendp = 0;
10439                   }
10440                 if (decl_context == NORMAL)
10441                   error ("friend declaration not in class definition");
10442                 if (current_function_decl && funcdef_flag)
10443                   cp_error ("can't define friend function `%s' in a local class definition",
10444                             name);
10445               }
10446
10447             /* Construct the function type and go to the next
10448                inner layer of declarator.  */
10449
10450             declarator = TREE_OPERAND (declarator, 0);
10451
10452             /* FIXME: This is where default args should be fully
10453                processed.  */
10454
10455             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10456
10457             if (declarator && flags == DTOR_FLAG)
10458               {
10459                 /* A destructor declared in the body of a class will
10460                    be represented as a BIT_NOT_EXPR.  But, we just
10461                    want the underlying IDENTIFIER.  */
10462                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10463                   declarator = TREE_OPERAND (declarator, 0);
10464
10465                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10466                   arg_types = void_list_node;
10467                 else if (arg_types == NULL_TREE
10468                          || arg_types != void_list_node)
10469                   {
10470                     cp_error ("destructors may not have parameters");
10471                     arg_types = void_list_node;
10472                     last_function_parms = NULL_TREE;
10473                   }
10474               }
10475
10476             /* ANSI says that `const int foo ();'
10477                does not make the function foo const.  */
10478             type = build_function_type (type, arg_types);
10479
10480             {
10481               tree t;
10482               for (t = arg_types; t; t = TREE_CHAIN (t))
10483                 if (TREE_PURPOSE (t)
10484                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10485                   {
10486                     add_defarg_fn (type);
10487                     break;
10488                   }
10489             }
10490           }
10491           break;
10492
10493         case ADDR_EXPR:
10494         case INDIRECT_REF:
10495           /* Filter out pointers-to-references and references-to-references.
10496              We can get these if a TYPE_DECL is used.  */
10497
10498           if (TREE_CODE (type) == REFERENCE_TYPE)
10499             {
10500               error ("cannot declare %s to references",
10501                      TREE_CODE (declarator) == ADDR_EXPR
10502                      ? "references" : "pointers");
10503               declarator = TREE_OPERAND (declarator, 0);
10504               continue;
10505             }
10506
10507           if (TREE_CODE (type) == OFFSET_TYPE
10508               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10509                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10510             {
10511               cp_error ("cannot declare pointer to `%#T' member",
10512                         TREE_TYPE (type));
10513               type = TREE_TYPE (type);
10514             }
10515
10516           /* Merge any constancy or volatility into the target type
10517              for the pointer.  */
10518
10519           /* We now know that the TYPE_QUALS don't apply to the decl,
10520              but to the target of the pointer.  */
10521           type_quals = TYPE_UNQUALIFIED;
10522
10523           if (TREE_CODE (declarator) == ADDR_EXPR)
10524             {
10525               if (TREE_CODE (type) == VOID_TYPE)
10526                 error ("invalid type: `void &'");
10527               else
10528                 type = build_reference_type (type);
10529             }
10530           else if (TREE_CODE (type) == METHOD_TYPE)
10531             type = build_ptrmemfunc_type (build_pointer_type (type));
10532           else
10533             type = build_pointer_type (type);
10534
10535           /* Process a list of type modifier keywords (such as
10536              const or volatile) that were given inside the `*' or `&'.  */
10537
10538           if (TREE_TYPE (declarator))
10539             {
10540               register tree typemodlist;
10541               int erred = 0;
10542
10543               constp = 0;
10544               volatilep = 0;
10545               restrictp = 0;
10546               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10547                    typemodlist = TREE_CHAIN (typemodlist))
10548                 {
10549                   tree qualifier = TREE_VALUE (typemodlist);
10550
10551                   if (qualifier == ridpointers[(int) RID_CONST])
10552                     constp++;
10553                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10554                     volatilep++;
10555                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10556                     restrictp++;
10557                   else if (!erred)
10558                     {
10559                       erred = 1;
10560                       error ("invalid type modifier within pointer declarator");
10561                     }
10562                 }
10563               if (constp > 1)
10564                 pedwarn ("duplicate `const'");
10565               if (volatilep > 1)
10566                 pedwarn ("duplicate `volatile'");
10567               if (restrictp > 1)
10568                 pedwarn ("duplicate `restrict'");
10569
10570               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10571                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10572                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10573               if (TREE_CODE (declarator) == ADDR_EXPR
10574                   && (constp || volatilep))
10575                 {
10576                   if (constp)
10577                     pedwarn ("discarding `const' applied to a reference");
10578                   if (volatilep)
10579                     pedwarn ("discarding `volatile' applied to a reference");
10580                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10581                 }
10582               type = cp_build_qualified_type (type, type_quals);
10583             }
10584           declarator = TREE_OPERAND (declarator, 0);
10585           ctype = NULL_TREE;
10586           break;
10587
10588         case SCOPE_REF:
10589           {
10590             /* We have converted type names to NULL_TREE if the
10591                name was bogus, or to a _TYPE node, if not.
10592
10593                The variable CTYPE holds the type we will ultimately
10594                resolve to.  The code here just needs to build
10595                up appropriate member types.  */
10596             tree sname = TREE_OPERAND (declarator, 1);
10597             tree t;
10598
10599             /* Destructors can have their visibilities changed as well.  */
10600             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10601               sname = TREE_OPERAND (sname, 0);
10602
10603             if (TREE_COMPLEXITY (declarator) == 0)
10604               /* This needs to be here, in case we are called
10605                  multiple times.  */ ;
10606             else if (TREE_COMPLEXITY (declarator) == -1)
10607               /* Namespace member. */
10608               pop_decl_namespace ();
10609             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10610               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10611             else if (! IS_AGGR_TYPE_CODE
10612                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10613               ;
10614             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10615               {
10616                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10617                    that refer to ctype.  They couldn't be resolved earlier
10618                    because we hadn't pushed into the class yet.
10619                    Example: resolve 'B<T>::type' in
10620                    'B<typename B<T>::type> B<T>::f () { }'.  */
10621                 if (current_template_parms
10622                     && uses_template_parms (type)
10623                     && uses_template_parms (current_class_type))
10624                   {
10625                     tree args = current_template_args ();
10626                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10627                   }
10628
10629                 /* This pop_nested_class corresponds to the
10630                    push_nested_class used to push into class scope for
10631                    parsing the argument list of a function decl, in
10632                    qualified_id.  */
10633                 pop_nested_class ();
10634                 TREE_COMPLEXITY (declarator) = current_class_depth;
10635               }
10636             else
10637               my_friendly_abort (16);
10638
10639             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10640               {
10641                 /* We had a reference to a global decl, or
10642                    perhaps we were given a non-aggregate typedef,
10643                    in which case we cleared this out, and should just
10644                    keep going as though it wasn't there.  */
10645                 declarator = sname;
10646                 continue;
10647               }
10648             ctype = TREE_OPERAND (declarator, 0);
10649
10650             t = ctype;
10651             while (t != NULL_TREE && CLASS_TYPE_P (t))
10652               {
10653                 if (CLASSTYPE_TEMPLATE_INFO (t) &&
10654                     !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
10655                   template_count += 1;
10656                 t = TYPE_MAIN_DECL (t);
10657                 if (DECL_LANG_SPECIFIC (t))
10658                   t = DECL_CONTEXT (t);
10659                 else
10660                   t = NULL_TREE;
10661               }
10662
10663             if (sname == NULL_TREE)
10664               goto done_scoping;
10665
10666             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10667               {
10668                 /* This is the `standard' use of the scoping operator:
10669                    basetype :: member .  */
10670
10671                 if (ctype == current_class_type)
10672                   {
10673                     /* class A {
10674                          void A::f ();
10675                        };
10676
10677                        Is this ill-formed?  */
10678
10679                     if (pedantic)
10680                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10681                                   ctype, name);
10682                   }
10683                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10684                   {
10685                     if (current_class_type == NULL_TREE
10686                         || friendp)
10687                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10688                                                       TYPE_ARG_TYPES (type));
10689                     else
10690                       {
10691                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10692                                   ctype, name, current_class_type);
10693                         return void_type_node;
10694                       }
10695                   }
10696                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10697                          || COMPLETE_TYPE_P (complete_type (ctype)))
10698                   {
10699                     /* Have to move this code elsewhere in this function.
10700                        this code is used for i.e., typedef int A::M; M *pm;
10701
10702                        It is?  How? jason 10/2/94 */
10703
10704                     if (current_class_type)
10705                       {
10706                         cp_error ("cannot declare member `%T::%s' within `%T'",
10707                                   ctype, name, current_class_type);
10708                         return void_type_node;
10709                       }
10710                     type = build_offset_type (ctype, type);
10711                   }
10712                 else if (uses_template_parms (ctype))
10713                   {
10714                     if (TREE_CODE (type) == FUNCTION_TYPE)
10715                       type
10716                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10717                                                    TYPE_ARG_TYPES (type));
10718                   }
10719                 else
10720                   {
10721                     cp_error ("structure `%T' not yet defined", ctype);
10722                     return error_mark_node;
10723                   }
10724
10725                 declarator = sname;
10726               }
10727             else if (TREE_CODE (sname) == SCOPE_REF)
10728               my_friendly_abort (17);
10729             else
10730               {
10731               done_scoping:
10732                 declarator = TREE_OPERAND (declarator, 1);
10733                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10734                   /* In this case, we will deal with it later.  */
10735                   ;
10736                 else
10737                   {
10738                     if (TREE_CODE (type) == FUNCTION_TYPE)
10739                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10740                                                       TYPE_ARG_TYPES (type));
10741                     else
10742                       type = build_offset_type (ctype, type);
10743                   }
10744               }
10745           }
10746           break;
10747
10748         case BIT_NOT_EXPR:
10749           declarator = TREE_OPERAND (declarator, 0);
10750           break;
10751
10752         case RECORD_TYPE:
10753         case UNION_TYPE:
10754         case ENUMERAL_TYPE:
10755           declarator = NULL_TREE;
10756           break;
10757
10758         case ERROR_MARK:
10759           declarator = NULL_TREE;
10760           break;
10761
10762         default:
10763           my_friendly_abort (158);
10764         }
10765     }
10766
10767   /* See the comment for the TREE_LIST case, above.  */
10768   if (inner_attrs)
10769     {
10770       if (! ignore_attrs)
10771         decl_attributes (type, inner_attrs, NULL_TREE);
10772       else if (attrlist)
10773         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10774       else
10775         attrlist = build_decl_list (NULL_TREE, inner_attrs);
10776     }
10777
10778   /* Now TYPE has the actual type.  */
10779
10780   if (explicitp == 1 || (explicitp && friendp))
10781     {
10782       /* [dcl.fct.spec] The explicit specifier shall only be used in
10783          declarations of constructors within a class definition.  */
10784       error ("only declarations of constructors can be `explicit'");
10785       explicitp = 0;
10786     }
10787
10788   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10789     {
10790       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10791         {
10792           error ("non-member `%s' cannot be declared `mutable'", name);
10793           RIDBIT_RESET (RID_MUTABLE, specbits);
10794         }
10795       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10796         {
10797           error ("non-object member `%s' cannot be declared `mutable'", name);
10798           RIDBIT_RESET (RID_MUTABLE, specbits);
10799         }
10800       else if (TREE_CODE (type) == FUNCTION_TYPE
10801                || TREE_CODE (type) == METHOD_TYPE)
10802         {
10803           error ("function `%s' cannot be declared `mutable'", name);
10804           RIDBIT_RESET (RID_MUTABLE, specbits);
10805         }
10806       else if (staticp)
10807         {
10808           error ("static `%s' cannot be declared `mutable'", name);
10809           RIDBIT_RESET (RID_MUTABLE, specbits);
10810         }
10811       else if (type_quals & TYPE_QUAL_CONST)
10812         {
10813           error ("const `%s' cannot be declared `mutable'", name);
10814           RIDBIT_RESET (RID_MUTABLE, specbits);
10815         }
10816     }
10817
10818   if (declarator == NULL_TREE
10819       || TREE_CODE (declarator) == IDENTIFIER_NODE
10820       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10821           && (TREE_CODE (type) == FUNCTION_TYPE
10822               || TREE_CODE (type) == METHOD_TYPE)))
10823     /* OK */;
10824   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10825     {
10826       cp_error ("template-id `%D' used as a declarator", declarator);
10827       declarator = dname;
10828     }
10829   else
10830     /* Unexpected declarator format.  */
10831     my_friendly_abort (990210);
10832
10833   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10834
10835   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10836     {
10837       tree decl;
10838
10839       /* Note that the grammar rejects storage classes
10840          in typenames, fields or parameters.  */
10841       if (current_lang_name == lang_name_java)
10842         TYPE_FOR_JAVA (type) = 1;
10843
10844       if (decl_context == FIELD)
10845         {
10846           if (declarator == constructor_name (current_class_type))
10847             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10848                         declarator);
10849           decl = build_lang_decl (TYPE_DECL, declarator, type);
10850         }
10851       else
10852         {
10853           /* Make sure this typedef lives as long as its type,
10854              since it might be used as a template parameter. */
10855           if (processing_template_decl)
10856             decl = build_lang_decl (TYPE_DECL, declarator, type);
10857           else
10858             decl = build_decl (TYPE_DECL, declarator, type);
10859         }
10860
10861       /* If the user declares "typedef struct {...} foo" then the
10862          struct will have an anonymous name.  Fill that name in now.
10863          Nothing can refer to it, so nothing needs know about the name
10864          change.  */
10865       if (type != error_mark_node
10866           && TYPE_NAME (type)
10867           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10868           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10869           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10870         {
10871           tree oldname = TYPE_NAME (type);
10872           tree t;
10873
10874           /* Replace the anonymous name with the real name everywhere.  */
10875           lookup_tag_reverse (type, declarator);
10876           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10877             if (TYPE_NAME (t) == oldname)
10878               TYPE_NAME (t) = decl;
10879
10880           if (TYPE_LANG_SPECIFIC (type))
10881             TYPE_WAS_ANONYMOUS (type) = 1;
10882
10883           /* If this is a typedef within a template class, the nested
10884              type is a (non-primary) template.  The name for the
10885              template needs updating as well.  */
10886           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10887             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10888               = TYPE_IDENTIFIER (type);
10889
10890           /* XXX Temporarily set the scope.
10891              When returning, start_decl expects it as NULL_TREE,
10892              and will then then set it using pushdecl. */
10893           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10894           if (current_class_type)
10895             DECL_CONTEXT (decl) = current_class_type;
10896           else
10897             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10898
10899           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10900           DECL_ASSEMBLER_NAME (decl)
10901             = get_identifier (build_overload_name (type, 1, 1));
10902           DECL_CONTEXT (decl) = NULL_TREE;
10903
10904           /* FIXME remangle member functions; member functions of a
10905              type with external linkage have external linkage.  */
10906         }
10907
10908       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10909         {
10910           cp_error_at ("typedef name may not be class-qualified", decl);
10911           return NULL_TREE;
10912         }
10913       else if (quals)
10914         {
10915           if (ctype == NULL_TREE)
10916             {
10917               if (TREE_CODE (type) != METHOD_TYPE)
10918                 cp_error_at ("invalid type qualifier for non-member function type", decl);
10919               else
10920                 ctype = TYPE_METHOD_BASETYPE (type);
10921             }
10922           if (ctype != NULL_TREE)
10923             grok_method_quals (ctype, decl, quals);
10924         }
10925
10926       if (RIDBIT_SETP (RID_SIGNED, specbits)
10927           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10928         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10929
10930       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
10931                       inlinep, friendp, raises != NULL_TREE);
10932
10933       if (initialized)
10934         error ("typedef declaration includes an initializer");
10935
10936       return decl;
10937     }
10938
10939   /* Detect the case of an array type of unspecified size
10940      which came, as such, direct from a typedef name.
10941      We must copy the type, so that each identifier gets
10942      a distinct type, so that each identifier's size can be
10943      controlled separately by its own initializer.  */
10944
10945   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
10946       && TYPE_DOMAIN (type) == NULL_TREE)
10947     {
10948       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
10949     }
10950
10951   /* If this is a type name (such as, in a cast or sizeof),
10952      compute the type and return it now.  */
10953
10954   if (decl_context == TYPENAME)
10955     {
10956       /* Note that the grammar rejects storage classes
10957          in typenames, fields or parameters.  */
10958       if (type_quals != TYPE_UNQUALIFIED)
10959         type_quals = TYPE_UNQUALIFIED;
10960
10961       /* Special case: "friend class foo" looks like a TYPENAME context.  */
10962       if (friendp)
10963         {
10964           if (type_quals != TYPE_UNQUALIFIED)
10965             {
10966               cp_error ("type qualifiers specified for friend class declaration");
10967               type_quals = TYPE_UNQUALIFIED;
10968             }
10969           if (inlinep)
10970             {
10971               cp_error ("`inline' specified for friend class declaration");
10972               inlinep = 0;
10973             }
10974
10975           /* Only try to do this stuff if we didn't already give up.  */
10976           if (type != integer_type_node)
10977             {
10978               /* A friendly class?  */
10979               if (current_class_type)
10980                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
10981               else
10982                 error ("trying to make class `%s' a friend of global scope",
10983                        TYPE_NAME_STRING (type));
10984               type = void_type_node;
10985             }
10986         }
10987       else if (quals)
10988         {
10989           if (ctype == NULL_TREE)
10990             {
10991               if (TREE_CODE (type) != METHOD_TYPE)
10992                 cp_error ("invalid qualifiers on non-member function type");
10993               else
10994                 ctype = TYPE_METHOD_BASETYPE (type);
10995             }
10996           if (ctype)
10997             {
10998               tree dummy = build_decl (TYPE_DECL, declarator, type);
10999               grok_method_quals (ctype, dummy, quals);
11000               type = TREE_TYPE (dummy);
11001             }
11002         }
11003
11004       return type;
11005     }
11006   else if (declarator == NULL_TREE && decl_context != PARM
11007            && decl_context != CATCHPARM
11008            && TREE_CODE (type) != UNION_TYPE
11009            && ! bitfield)
11010     {
11011       cp_error ("abstract declarator `%T' used as declaration", type);
11012       declarator = make_anon_name ();
11013     }
11014
11015   /* `void' at top level (not within pointer)
11016      is allowed only in typedefs or type names.
11017      We don't complain about parms either, but that is because
11018      a better error message can be made later.  */
11019
11020   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11021     {
11022       if (! declarator)
11023         error ("unnamed variable or field declared void");
11024       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11025         {
11026           if (IDENTIFIER_OPNAME_P (declarator))
11027             my_friendly_abort (356);
11028           else
11029             error ("variable or field `%s' declared void", name);
11030         }
11031       else
11032         error ("variable or field declared void");
11033       type = integer_type_node;
11034     }
11035
11036   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11037      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11038
11039   if (decl_context == PARM || decl_context == CATCHPARM)
11040     {
11041       if (ctype || in_namespace)
11042         error ("cannot use `::' in parameter declaration");
11043
11044       /* A parameter declared as an array of T is really a pointer to T.
11045          One declared as a function is really a pointer to a function.
11046          One declared as a member is really a pointer to member.  */
11047
11048       if (TREE_CODE (type) == ARRAY_TYPE)
11049         {
11050           /* Transfer const-ness of array into that of type pointed to.  */
11051           type = build_pointer_type (TREE_TYPE (type));
11052           type_quals = TYPE_UNQUALIFIED;
11053         }
11054       else if (TREE_CODE (type) == FUNCTION_TYPE)
11055         type = build_pointer_type (type);
11056       else if (TREE_CODE (type) == OFFSET_TYPE)
11057         type = build_pointer_type (type);
11058       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11059         {
11060           error ("declaration of `%s' as void", name);
11061           return NULL_TREE;
11062         }
11063     }
11064
11065   {
11066     register tree decl;
11067
11068     if (decl_context == PARM)
11069       {
11070         decl = build_decl (PARM_DECL, declarator, type);
11071
11072         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11073                         inlinep, friendp, raises != NULL_TREE);
11074
11075         /* Compute the type actually passed in the parmlist,
11076            for the case where there is no prototype.
11077            (For example, shorts and chars are passed as ints.)
11078            When there is a prototype, this is overridden later.  */
11079
11080         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11081       }
11082     else if (decl_context == FIELD)
11083       {
11084         if (type == error_mark_node)
11085           {
11086             /* Happens when declaring arrays of sizes which
11087                are error_mark_node, for example.  */
11088             decl = NULL_TREE;
11089           }
11090         else if (in_namespace && !friendp)
11091           {
11092             /* Something like struct S { int N::j; };  */
11093             cp_error ("invalid use of `::'");
11094             decl = NULL_TREE;
11095           }
11096         else if (TREE_CODE (type) == FUNCTION_TYPE)
11097           {
11098             int publicp = 0;
11099             tree function_context;
11100
11101             /* We catch the others as conflicts with the builtin
11102                typedefs.  */
11103             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11104               {
11105                 cp_error ("function `%D' cannot be declared friend",
11106                           declarator);
11107                 friendp = 0;
11108               }
11109
11110             if (friendp == 0)
11111               {
11112                 if (ctype == NULL_TREE)
11113                   ctype = current_class_type;
11114
11115                 if (ctype == NULL_TREE)
11116                   {
11117                     cp_error ("can't make `%D' into a method -- not in a class",
11118                               declarator);
11119                     return void_type_node;
11120                   }
11121
11122                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11123                    ARM 9.5 */
11124                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11125                   {
11126                     cp_error ("function `%D' declared virtual inside a union",
11127                               declarator);
11128                     return void_type_node;
11129                   }
11130
11131                 if (declarator == ansi_opname[(int) NEW_EXPR]
11132                     || declarator == ansi_opname[(int) VEC_NEW_EXPR]
11133                     || declarator == ansi_opname[(int) DELETE_EXPR]
11134                     || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
11135                   {
11136                     if (virtualp)
11137                       {
11138                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11139                                   declarator);
11140                         virtualp = 0;
11141                       }
11142                   }
11143                 else if (staticp < 2)
11144                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11145                                                   TYPE_ARG_TYPES (type));
11146               }
11147
11148             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11149             function_context = (ctype != NULL_TREE) ?
11150               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11151             publicp = (! friendp || ! staticp)
11152               && function_context == NULL_TREE;
11153             decl = grokfndecl (ctype, type,
11154                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11155                                ? declarator : dname,
11156                                declarator,
11157                                virtualp, flags, quals, raises,
11158                                friendp ? -1 : 0, friendp, publicp, inlinep,
11159                                funcdef_flag, template_count, in_namespace);
11160             if (decl == NULL_TREE)
11161               return decl;
11162 #if 0
11163             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11164             /* The decl and setting of decl_machine_attr is also turned off.  */
11165             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11166 #endif
11167
11168             /* [class.conv.ctor]
11169
11170                A constructor declared without the function-specifier
11171                explicit that can be called with a single parameter
11172                specifies a conversion from the type of its first
11173                parameter to the type of its class.  Such a constructor
11174                is called a converting constructor.  */
11175             if (explicitp == 2)
11176               DECL_NONCONVERTING_P (decl) = 1;
11177             else if (DECL_CONSTRUCTOR_P (decl))
11178               {
11179                 /* The constructor can be called with exactly one
11180                    parameter if there is at least one parameter, and
11181                    any subsequent parameters have default arguments.
11182                    We don't look at the first parameter, which is
11183                    really just the `this' parameter for the new
11184                    object.  */
11185                 tree arg_types =
11186                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11187
11188                 /* Skip the `in_chrg' argument too, if present.  */
11189                 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl)))
11190                   arg_types = TREE_CHAIN (arg_types);
11191
11192                 if (arg_types == void_list_node
11193                     || (arg_types
11194                         && TREE_CHAIN (arg_types)
11195                         && TREE_CHAIN (arg_types) != void_list_node
11196                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11197                   DECL_NONCONVERTING_P (decl) = 1;
11198               }
11199           }
11200         else if (TREE_CODE (type) == METHOD_TYPE)
11201           {
11202             /* We only get here for friend declarations of
11203                members of other classes.  */
11204             /* All method decls are public, so tell grokfndecl to set
11205                TREE_PUBLIC, also.  */
11206             decl = grokfndecl (ctype, type, declarator, declarator,
11207                                virtualp, flags, quals, raises,
11208                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11209                                template_count, in_namespace);
11210             if (decl == NULL_TREE)
11211               return NULL_TREE;
11212           }
11213         else if (!staticp && ! processing_template_decl
11214                  && !COMPLETE_TYPE_P (complete_type (type))
11215                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11216           {
11217             if (declarator)
11218               cp_error ("field `%D' has incomplete type", declarator);
11219             else
11220               cp_error ("name `%T' has incomplete type", type);
11221
11222             /* If we're instantiating a template, tell them which
11223                instantiation made the field's type be incomplete.  */
11224             if (current_class_type
11225                 && TYPE_NAME (current_class_type)
11226                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11227                 && declspecs && TREE_VALUE (declspecs)
11228                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11229               cp_error ("  in instantiation of template `%T'",
11230                         current_class_type);
11231
11232             type = error_mark_node;
11233             decl = NULL_TREE;
11234           }
11235         else
11236           {
11237             if (friendp)
11238               {
11239                 error ("`%s' is neither function nor member function; cannot be declared friend",
11240                        IDENTIFIER_POINTER (declarator));
11241                 friendp = 0;
11242               }
11243             decl = NULL_TREE;
11244           }
11245
11246         if (friendp)
11247           {
11248             /* Friends are treated specially.  */
11249             if (ctype == current_class_type)
11250               warning ("member functions are implicitly friends of their class");
11251             else
11252               {
11253                 tree t = NULL_TREE;
11254                 if (decl && DECL_NAME (decl))
11255                   {
11256                     if (template_class_depth (current_class_type) == 0)
11257                       {
11258                         decl
11259                           = check_explicit_specialization
11260                           (declarator, decl,
11261                            template_count, 2 * (funcdef_flag != 0) + 4);
11262                         if (decl == error_mark_node)
11263                           return error_mark_node;
11264                       }
11265
11266                     t = do_friend (ctype, declarator, decl,
11267                                    last_function_parms, attrlist, flags, quals,
11268                                    funcdef_flag);
11269                   }
11270                 if (t && funcdef_flag)
11271                   return t;
11272
11273                 return void_type_node;
11274               }
11275           }
11276
11277         /* Structure field.  It may not be a function, except for C++ */
11278
11279         if (decl == NULL_TREE)
11280           {
11281             if (initialized)
11282               {
11283                 if (!staticp)
11284                   {
11285                     /* An attempt is being made to initialize a non-static
11286                        member.  But, from [class.mem]:
11287
11288                        4 A member-declarator can contain a
11289                        constant-initializer only if it declares a static
11290                        member (_class.static_) of integral or enumeration
11291                        type, see _class.static.data_.
11292
11293                        This used to be relatively common practice, but
11294                        the rest of the compiler does not correctly
11295                        handle the initialization unless the member is
11296                        static so we make it static below.  */
11297                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11298                                 declarator);
11299                     cp_pedwarn ("making `%D' static", declarator);
11300                     staticp = 1;
11301                   }
11302
11303                 if (uses_template_parms (type))
11304                   /* We'll check at instantiation time.  */
11305                   ;
11306                 else if (check_static_variable_definition (declarator,
11307                                                            type))
11308                   /* If we just return the declaration, crashes
11309                      will sometimes occur.  We therefore return
11310                      void_type_node, as if this was a friend
11311                      declaration, to cause callers to completely
11312                      ignore this declaration.  */
11313                   return void_type_node;
11314               }
11315
11316             /* 9.2p13 [class.mem] */
11317             if (declarator == constructor_name (current_class_type)
11318                 /* Divergence from the standard:  In extern "C", we
11319                    allow non-static data members here, because C does
11320                    and /usr/include/netinet/in.h uses that.  */
11321                 && (staticp || ! in_system_header))
11322               cp_pedwarn ("ISO C++ forbids data member `%D' with same name as enclosing class",
11323                           declarator);
11324
11325             if (staticp)
11326               {
11327                 /* C++ allows static class members.  All other work
11328                    for this is done by grokfield.  */
11329                 decl = build_lang_decl (VAR_DECL, declarator, type);
11330                 TREE_STATIC (decl) = 1;
11331                 /* In class context, 'static' means public access.  */
11332                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11333               }
11334             else
11335               {
11336                 decl = build_lang_decl (FIELD_DECL, declarator, type);
11337                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11338                   {
11339                     DECL_MUTABLE_P (decl) = 1;
11340                     RIDBIT_RESET (RID_MUTABLE, specbits);
11341                   }
11342               }
11343
11344             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11345                             inlinep, friendp, raises != NULL_TREE);
11346           }
11347       }
11348     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11349       {
11350         tree original_name;
11351         int publicp = 0;
11352
11353         if (! declarator)
11354           return NULL_TREE;
11355
11356         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11357           original_name = dname;
11358         else
11359           original_name = declarator;
11360
11361         if (RIDBIT_SETP (RID_AUTO, specbits))
11362           error ("storage class `auto' invalid for function `%s'", name);
11363         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11364           error ("storage class `register' invalid for function `%s'", name);
11365
11366         /* Function declaration not at top level.
11367            Storage classes other than `extern' are not allowed
11368            and `extern' makes no difference.  */
11369         if (! toplevel_bindings_p ()
11370             && (RIDBIT_SETP (RID_STATIC, specbits)
11371                 || RIDBIT_SETP (RID_INLINE, specbits))
11372             && pedantic)
11373           {
11374             if (RIDBIT_SETP (RID_STATIC, specbits))
11375               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11376             else
11377               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11378           }
11379
11380         if (ctype == NULL_TREE)
11381           {
11382             if (virtualp)
11383               {
11384                 error ("virtual non-class function `%s'", name);
11385                 virtualp = 0;
11386               }
11387           }
11388         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11389           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11390                                           TYPE_ARG_TYPES (type));
11391
11392         /* Record presence of `static'.  */
11393         publicp = (ctype != NULL_TREE
11394                    || RIDBIT_SETP (RID_EXTERN, specbits)
11395                    || !RIDBIT_SETP (RID_STATIC, specbits));
11396
11397         decl = grokfndecl (ctype, type, original_name, declarator,
11398                            virtualp, flags, quals, raises,
11399                            1, friendp,
11400                            publicp, inlinep, funcdef_flag,
11401                            template_count, in_namespace);
11402         if (decl == NULL_TREE)
11403           return NULL_TREE;
11404
11405         if (staticp == 1)
11406           {
11407             int illegal_static = 0;
11408
11409             /* Don't allow a static member function in a class, and forbid
11410                declaring main to be static.  */
11411             if (TREE_CODE (type) == METHOD_TYPE)
11412               {
11413                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11414                 illegal_static = 1;
11415               }
11416             else if (current_function_decl)
11417               {
11418                 /* FIXME need arm citation */
11419                 error ("cannot declare static function inside another function");
11420                 illegal_static = 1;
11421               }
11422
11423             if (illegal_static)
11424               {
11425                 staticp = 0;
11426                 RIDBIT_RESET (RID_STATIC, specbits);
11427               }
11428           }
11429       }
11430     else
11431       {
11432         /* It's a variable.  */
11433
11434         /* An uninitialized decl with `extern' is a reference.  */
11435         decl = grokvardecl (type, declarator, &specbits,
11436                             initialized,
11437                             (type_quals & TYPE_QUAL_CONST) != 0,
11438                             in_namespace);
11439         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11440                         inlinep, friendp, raises != NULL_TREE);
11441
11442         if (ctype)
11443           {
11444             DECL_CONTEXT (decl) = ctype;
11445             if (staticp == 1)
11446               {
11447                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11448                 staticp = 0;
11449                 RIDBIT_RESET (RID_STATIC, specbits);
11450               }
11451             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11452               {
11453                 cp_error ("static member `%D' declared `register'", decl);
11454                 RIDBIT_RESET (RID_REGISTER, specbits);
11455               }
11456             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11457               {
11458                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11459                             decl);
11460                 RIDBIT_RESET (RID_EXTERN, specbits);
11461               }
11462           }
11463       }
11464
11465     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11466
11467     /* Record `register' declaration for warnings on &
11468        and in case doing stupid register allocation.  */
11469
11470     if (RIDBIT_SETP (RID_REGISTER, specbits))
11471       DECL_REGISTER (decl) = 1;
11472
11473     if (RIDBIT_SETP (RID_EXTERN, specbits))
11474       DECL_THIS_EXTERN (decl) = 1;
11475
11476     if (RIDBIT_SETP (RID_STATIC, specbits))
11477       DECL_THIS_STATIC (decl) = 1;
11478
11479     /* Record constancy and volatility.  There's no need to do this
11480        when processing a template; we'll do this for the instantiated
11481        declaration based on the type of DECL.  */
11482     if (!processing_template_decl)
11483       c_apply_type_quals_to_decl (type_quals, decl);
11484
11485     return decl;
11486   }
11487 }
11488 \f
11489 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11490    An empty exprlist is a parmlist.  An exprlist which
11491    contains only identifiers at the global level
11492    is a parmlist.  Otherwise, it is an exprlist.  */
11493
11494 int
11495 parmlist_is_exprlist (exprs)
11496      tree exprs;
11497 {
11498   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11499     return 0;
11500
11501   if (toplevel_bindings_p ())
11502     {
11503       /* At the global level, if these are all identifiers,
11504          then it is a parmlist.  */
11505       while (exprs)
11506         {
11507           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11508             return 1;
11509           exprs = TREE_CHAIN (exprs);
11510         }
11511       return 0;
11512     }
11513   return 1;
11514 }
11515
11516 /* Subroutine of start_function.  Ensure that each of the parameter
11517    types (as listed in PARMS) is complete, as is required for a
11518    function definition.  */
11519
11520 static void
11521 require_complete_types_for_parms (parms)
11522      tree parms;
11523 {
11524   for (; parms; parms = TREE_CHAIN (parms))
11525     {
11526       tree type = TREE_TYPE (parms);
11527
11528       /* Try to complete the TYPE.  */
11529       type = complete_type (type);
11530
11531       if (type == error_mark_node)
11532         continue;
11533
11534       if (!COMPLETE_TYPE_P (type))
11535         {
11536           if (DECL_NAME (parms))
11537             error ("parameter `%s' has incomplete type",
11538                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11539           else
11540             error ("parameter has incomplete type");
11541           TREE_TYPE (parms) = error_mark_node;
11542         }
11543       else
11544         layout_decl (parms, 0);
11545     }
11546 }
11547
11548 /* Returns non-zero if T is a local variable.  */
11549
11550 int
11551 local_variable_p (t)
11552      tree t;
11553 {
11554   if ((TREE_CODE (t) == VAR_DECL
11555        /* A VAR_DECL with a context that is a _TYPE is a static data
11556           member.  */
11557        && !TYPE_P (CP_DECL_CONTEXT (t))
11558        /* Any other non-local variable must be at namespace scope.  */
11559        && !DECL_NAMESPACE_SCOPE_P (t))
11560       || (TREE_CODE (t) == PARM_DECL))
11561     return 1;
11562
11563   return 0;
11564 }
11565
11566 /* Returns non-zero if T is an automatic local variable or a label.
11567    (These are the declarations that need to be remapped when the code
11568    containing them is duplicated.)  */
11569
11570 int
11571 nonstatic_local_decl_p (t)
11572      tree t;
11573 {
11574   return ((local_variable_p (t) && !TREE_STATIC (t))
11575           || TREE_CODE (t) == LABEL_DECL
11576           || TREE_CODE (t) == RESULT_DECL);
11577 }
11578
11579 /* Like local_variable_p, but suitable for use as a tree-walking
11580    function.  */
11581
11582 static tree
11583 local_variable_p_walkfn (tp, walk_subtrees, data)
11584      tree *tp;
11585      int *walk_subtrees ATTRIBUTE_UNUSED;
11586      void *data ATTRIBUTE_UNUSED;
11587 {
11588   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11589           ? *tp : NULL_TREE);
11590 }
11591
11592 /* Check that ARG, which is a default-argument expression for a
11593    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11594    something goes wrong.  DECL may also be a _TYPE node, rather than a
11595    DECL, if there is no DECL available.  */
11596
11597 tree
11598 check_default_argument (decl, arg)
11599      tree decl;
11600      tree arg;
11601 {
11602   tree var;
11603   tree decl_type;
11604
11605   if (TREE_CODE (arg) == DEFAULT_ARG)
11606     /* We get a DEFAULT_ARG when looking at an in-class declaration
11607        with a default argument.  Ignore the argument for now; we'll
11608        deal with it after the class is complete.  */
11609     return arg;
11610
11611   if (processing_template_decl || uses_template_parms (arg))
11612     /* We don't do anything checking until instantiation-time.  Note
11613        that there may be uninstantiated arguments even for an
11614        instantiated function, since default arguments are not
11615        instantiated until they are needed.  */
11616     return arg;
11617
11618   if (TYPE_P (decl))
11619     {
11620       decl_type = decl;
11621       decl = NULL_TREE;
11622     }
11623   else
11624     decl_type = TREE_TYPE (decl);
11625
11626   if (arg == error_mark_node
11627       || decl == error_mark_node
11628       || TREE_TYPE (arg) == error_mark_node
11629       || decl_type == error_mark_node)
11630     /* Something already went wrong.  There's no need to check
11631        further.  */
11632     return error_mark_node;
11633
11634   /* [dcl.fct.default]
11635
11636      A default argument expression is implicitly converted to the
11637      parameter type.  */
11638   if (!TREE_TYPE (arg)
11639       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11640     {
11641       if (decl)
11642         cp_error ("default argument for `%#D' has type `%T'",
11643                   decl, TREE_TYPE (arg));
11644       else
11645         cp_error ("default argument for parameter of type `%T' has type `%T'",
11646                   decl_type, TREE_TYPE (arg));
11647
11648       return error_mark_node;
11649     }
11650
11651   /* [dcl.fct.default]
11652
11653      Local variables shall not be used in default argument
11654      expressions.
11655
11656      The keyword `this' shall not be used in a default argument of a
11657      member function.  */
11658   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11659   if (var)
11660     {
11661       cp_error ("default argument `%E' uses local variable `%D'",
11662                 arg, var);
11663       return error_mark_node;
11664     }
11665
11666   /* All is well.  */
11667   return arg;
11668 }
11669
11670 /* Decode the list of parameter types for a function type.
11671    Given the list of things declared inside the parens,
11672    return a list of types.
11673
11674    The list we receive can have three kinds of elements:
11675    an IDENTIFIER_NODE for names given without types,
11676    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11677    or void_type_node, to mark the end of an argument list
11678    when additional arguments are not permitted (... was not used).
11679
11680    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11681    a mere declaration.  A nonempty identifier-list gets an error message
11682    when FUNCDEF_FLAG is zero.
11683    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11684    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11685
11686    If all elements of the input list contain types,
11687    we return a list of the types.
11688    If all elements contain no type (except perhaps a void_type_node
11689    at the end), we return a null list.
11690    If some have types and some do not, it is an error, and we
11691    return a null list.
11692
11693    Also set last_function_parms to either
11694    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11695    A list of names is converted to a chain of PARM_DECLs
11696    by store_parm_decls so that ultimately it is always a chain of decls.
11697
11698    Note that in C++, parameters can take default values.  These default
11699    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11700    an error to specify default values which are followed by parameters
11701    that have no default values, or an ELLIPSES.  For simplicities sake,
11702    only parameters which are specified with their types can take on
11703    default values.  */
11704
11705 static tree
11706 grokparms (first_parm, funcdef_flag)
11707      tree first_parm;
11708      int funcdef_flag;
11709 {
11710   tree result = NULL_TREE;
11711   tree decls = NULL_TREE;
11712
11713   if (first_parm != NULL_TREE
11714       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11715     {
11716       if (! funcdef_flag)
11717         pedwarn ("parameter names (without types) in function declaration");
11718       last_function_parms = first_parm;
11719       return NULL_TREE;
11720     }
11721   else if (first_parm != NULL_TREE
11722            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11723            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11724     my_friendly_abort (145);
11725   else
11726     {
11727       /* Types were specified.  This is a list of declarators
11728          each represented as a TREE_LIST node.  */
11729       register tree parm, chain;
11730       int any_init = 0, any_error = 0;
11731
11732       if (first_parm != NULL_TREE)
11733         {
11734           tree last_result = NULL_TREE;
11735           tree last_decl = NULL_TREE;
11736
11737           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11738             {
11739               tree type = NULL_TREE, list_node = parm;
11740               register tree decl = TREE_VALUE (parm);
11741               tree init = TREE_PURPOSE (parm);
11742
11743               chain = TREE_CHAIN (parm);
11744               /* @@ weak defense against parse errors.  */
11745               if (TREE_CODE (decl) != VOID_TYPE
11746                   && TREE_CODE (decl) != TREE_LIST)
11747                 {
11748                   /* Give various messages as the need arises.  */
11749                   if (TREE_CODE (decl) == STRING_CST)
11750                     cp_error ("invalid string constant `%E'", decl);
11751                   else if (TREE_CODE (decl) == INTEGER_CST)
11752                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11753                   continue;
11754                 }
11755
11756               if (TREE_CODE (decl) != VOID_TYPE)
11757                 {
11758                   decl = grokdeclarator (TREE_VALUE (decl),
11759                                          TREE_PURPOSE (decl),
11760                                          PARM, init != NULL_TREE,
11761                                          NULL_TREE);
11762                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11763                     continue;
11764
11765                   /* Top-level qualifiers on the parameters are
11766                      ignored for function types.  */
11767                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11768
11769                   if (TREE_CODE (type) == VOID_TYPE)
11770                     decl = void_type_node;
11771                   else if (TREE_CODE (type) == METHOD_TYPE)
11772                     {
11773                       if (DECL_NAME (decl))
11774                         /* Cannot use the decl here because
11775                            we don't have DECL_CONTEXT set up yet.  */
11776                         cp_error ("parameter `%D' invalidly declared method type",
11777                                   DECL_NAME (decl));
11778                       else
11779                         error ("parameter invalidly declared method type");
11780                       type = build_pointer_type (type);
11781                       TREE_TYPE (decl) = type;
11782                     }
11783                   else if (TREE_CODE (type) == OFFSET_TYPE)
11784                     {
11785                       if (DECL_NAME (decl))
11786                         cp_error ("parameter `%D' invalidly declared offset type",
11787                                   DECL_NAME (decl));
11788                       else
11789                         error ("parameter invalidly declared offset type");
11790                       type = build_pointer_type (type);
11791                       TREE_TYPE (decl) = type;
11792                     }
11793                   else if (abstract_virtuals_error (decl, type))
11794                     any_error = 1;  /* Seems like a good idea. */
11795                   else if (POINTER_TYPE_P (type))
11796                     {
11797                       tree t = type;
11798                       while (POINTER_TYPE_P (t)
11799                              || (TREE_CODE (t) == ARRAY_TYPE
11800                                  && TYPE_DOMAIN (t) != NULL_TREE))
11801                         t = TREE_TYPE (t);
11802                       if (TREE_CODE (t) == ARRAY_TYPE)
11803                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
11804                                   type,
11805                                   TYPE_PTR_P (type) ? "pointer" : "reference");
11806                     }
11807                 }
11808
11809               if (TREE_CODE (decl) == VOID_TYPE)
11810                 {
11811                   if (result == NULL_TREE)
11812                     {
11813                       result = void_list_node;
11814                       last_result = result;
11815                     }
11816                   else
11817                     {
11818                       TREE_CHAIN (last_result) = void_list_node;
11819                       last_result = void_list_node;
11820                     }
11821                   if (chain
11822                       && (chain != void_list_node || TREE_CHAIN (chain)))
11823                     error ("`void' in parameter list must be entire list");
11824                   break;
11825                 }
11826
11827               /* Since there is a prototype, args are passed in their own types.  */
11828               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11829               if (PROMOTE_PROTOTYPES
11830                   && (TREE_CODE (type) == INTEGER_TYPE
11831                       || TREE_CODE (type) == ENUMERAL_TYPE)
11832                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11833                 DECL_ARG_TYPE (decl) = integer_type_node;
11834               if (!any_error && init)
11835                 {
11836                   any_init++;
11837                   init = check_default_argument (decl, init);
11838                 }
11839               else
11840                 init = NULL_TREE;
11841
11842               if (decls == NULL_TREE)
11843                 {
11844                   decls = decl;
11845                   last_decl = decls;
11846                 }
11847               else
11848                 {
11849                   TREE_CHAIN (last_decl) = decl;
11850                   last_decl = decl;
11851                 }
11852               list_node = tree_cons (init, type, NULL_TREE);
11853               if (result == NULL_TREE)
11854                 {
11855                   result = list_node;
11856                   last_result = result;
11857                 }
11858               else
11859                 {
11860                   TREE_CHAIN (last_result) = list_node;
11861                   last_result = list_node;
11862                 }
11863             }
11864           if (last_result)
11865             TREE_CHAIN (last_result) = NULL_TREE;
11866           /* If there are no parameters, and the function does not end
11867              with `...', then last_decl will be NULL_TREE.  */
11868           if (last_decl != NULL_TREE)
11869             TREE_CHAIN (last_decl) = NULL_TREE;
11870         }
11871     }
11872
11873   last_function_parms = decls;
11874
11875   return result;
11876 }
11877
11878 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11879    FUNCTION_TYPE with the newly parsed version of its default argument, which
11880    was previously digested as text.  See snarf_defarg et al in lex.c.  */
11881
11882 void
11883 replace_defarg (arg, init)
11884      tree arg, init;
11885 {
11886   if (! processing_template_decl
11887       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11888     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11889                 TREE_TYPE (init), TREE_VALUE (arg));
11890   TREE_PURPOSE (arg) = init;
11891 }
11892 \f
11893 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11894    D's arguments allow it to be a copy constructor, or copy assignment
11895    operator.  */
11896
11897 int
11898 copy_args_p (d)
11899      tree d;
11900 {
11901   tree t;
11902
11903   if (!DECL_FUNCTION_MEMBER_P (d))
11904     return 0;
11905
11906   t = FUNCTION_ARG_CHAIN (d);
11907   if (DECL_CONSTRUCTOR_P (d)
11908       && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
11909     t = TREE_CHAIN (t);
11910   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11911       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11912           == DECL_CONTEXT (d))
11913       && (TREE_CHAIN (t) == NULL_TREE
11914           || TREE_CHAIN (t) == void_list_node
11915           || TREE_PURPOSE (TREE_CHAIN (t))))
11916     return 1;
11917   return 0;
11918 }
11919
11920 /* These memoizing functions keep track of special properties which
11921    a class may have.  `grok_ctor_properties' notices whether a class
11922    has a constructor of the form X(X&), and also complains
11923    if the class has a constructor of the form X(X).
11924    `grok_op_properties' takes notice of the various forms of
11925    operator= which are defined, as well as what sorts of type conversion
11926    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11927
11928 int
11929 grok_ctor_properties (ctype, decl)
11930      tree ctype, decl;
11931 {
11932   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11933   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11934
11935   /* When a type has virtual baseclasses, a magical first int argument is
11936      added to any ctor so we can tell if the class has been initialized
11937      yet.  This could screw things up in this function, so we deliberately
11938      ignore the leading int if we're in that situation.  */
11939   if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
11940     {
11941       my_friendly_assert (parmtypes
11942                           && TREE_VALUE (parmtypes) == integer_type_node,
11943                           980529);
11944       parmtypes = TREE_CHAIN (parmtypes);
11945       parmtype = TREE_VALUE (parmtypes);
11946     }
11947
11948   /* [class.copy]
11949
11950      A non-template constructor for class X is a copy constructor if
11951      its first parameter is of type X&, const X&, volatile X& or const
11952      volatile X&, and either there are no other parameters or else all
11953      other parameters have default arguments.  */
11954   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11955       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11956       && (TREE_CHAIN (parmtypes) == NULL_TREE
11957           || TREE_CHAIN (parmtypes) == void_list_node
11958           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11959       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11960            && is_member_template (DECL_TI_TEMPLATE (decl))))
11961     {
11962       TYPE_HAS_INIT_REF (ctype) = 1;
11963       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11964         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11965     }
11966   /* [class.copy]
11967
11968      A declaration of a constructor for a class X is ill-formed if its
11969      first parameter is of type (optionally cv-qualified) X and either
11970      there are no other parameters or else all other parameters have
11971      default arguments.
11972
11973      We *don't* complain about member template instantiations that
11974      have this form, though; they can occur as we try to decide what
11975      constructor to use during overload resolution.  Since overload
11976      resolution will never prefer such a constructor to the
11977      non-template copy constructor (which is either explicitly or
11978      implicitly defined), there's no need to worry about their
11979      existence.  Theoretically, they should never even be
11980      instantiated, but that's hard to forestall.  */
11981   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11982            && (TREE_CHAIN (parmtypes) == NULL_TREE
11983                || TREE_CHAIN (parmtypes) == void_list_node
11984                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11985            && !(DECL_TEMPLATE_INSTANTIATION (decl)
11986                 && is_member_template (DECL_TI_TEMPLATE (decl))))
11987     {
11988       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11989                 ctype, ctype);
11990       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
11991       return 0;
11992     }
11993   else if (TREE_CODE (parmtype) == VOID_TYPE
11994            || TREE_PURPOSE (parmtypes) != NULL_TREE)
11995     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
11996
11997   return 1;
11998 }
11999
12000 /* An operator with this name can be either unary or binary.  */
12001
12002 static int
12003 ambi_op_p (name)
12004      tree name;
12005 {
12006   return (name == ansi_opname [(int) INDIRECT_REF]
12007           || name == ansi_opname [(int) ADDR_EXPR]
12008           || name == ansi_opname [(int) NEGATE_EXPR]
12009           || name == ansi_opname[(int) POSTINCREMENT_EXPR]
12010           || name == ansi_opname[(int) POSTDECREMENT_EXPR]
12011           || name == ansi_opname [(int) CONVERT_EXPR]);
12012 }
12013
12014 /* An operator with this name can only be unary.  */
12015
12016 static int
12017 unary_op_p (name)
12018      tree name;
12019 {
12020   return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
12021           || name == ansi_opname [(int) BIT_NOT_EXPR]
12022           || name == ansi_opname [(int) COMPONENT_REF]
12023           || IDENTIFIER_TYPENAME_P (name));
12024 }
12025
12026 /* Do a little sanity-checking on how they declared their operator.  */
12027
12028 void
12029 grok_op_properties (decl, virtualp, friendp)
12030      tree decl;
12031      int virtualp, friendp;
12032 {
12033   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12034   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12035   tree name = DECL_NAME (decl);
12036
12037   if (current_class_type == NULL_TREE)
12038     friendp = 1;
12039
12040   if (! friendp)
12041     {
12042       /* [class.copy]
12043
12044          A user-declared copy assignment operator X::operator= is a
12045          non-static non-template member function of class X with
12046          exactly one parameter of type X, X&, const X&, volatile X& or
12047          const volatile X&.  */
12048       if (name == ansi_opname[(int) MODIFY_EXPR]
12049           && !(DECL_TEMPLATE_INSTANTIATION (decl)
12050                && is_member_template (DECL_TI_TEMPLATE (decl))))
12051         ;
12052       else if (name == ansi_opname[(int) CALL_EXPR])
12053         TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12054       else if (name == ansi_opname[(int) ARRAY_REF])
12055         TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12056       else if (name == ansi_opname[(int) COMPONENT_REF]
12057                || name == ansi_opname[(int) MEMBER_REF])
12058         TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12059       else if (name == ansi_opname[(int) NEW_EXPR])
12060         TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12061       else if (name == ansi_opname[(int) DELETE_EXPR])
12062         TYPE_GETS_DELETE (current_class_type) |= 1;
12063       else if (name == ansi_opname[(int) VEC_NEW_EXPR])
12064         TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12065       else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
12066         TYPE_GETS_DELETE (current_class_type) |= 2;
12067     }
12068
12069   if (name == ansi_opname[(int) NEW_EXPR]
12070       || name == ansi_opname[(int) VEC_NEW_EXPR])
12071     {
12072       /* When the compiler encounters the definition of A::operator new, it
12073          doesn't look at the class declaration to find out if it's static.  */
12074       if (methodp)
12075         revert_static_member_fn (decl);
12076
12077       /* Take care of function decl if we had syntax errors.  */
12078       if (argtypes == NULL_TREE)
12079         TREE_TYPE (decl)
12080           = build_function_type (ptr_type_node,
12081                                  hash_tree_chain (integer_type_node,
12082                                                   void_list_node));
12083       else
12084         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12085     }
12086   else if (name == ansi_opname[(int) DELETE_EXPR]
12087            || name == ansi_opname[(int) VEC_DELETE_EXPR])
12088     {
12089       if (methodp)
12090         revert_static_member_fn (decl);
12091
12092       if (argtypes == NULL_TREE)
12093         TREE_TYPE (decl)
12094           = build_function_type (void_type_node,
12095                                  hash_tree_chain (ptr_type_node,
12096                                                   void_list_node));
12097       else
12098         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12099     }
12100   else
12101     {
12102       /* An operator function must either be a non-static member function
12103          or have at least one parameter of a class, a reference to a class,
12104          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12105       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12106         {
12107           if (IDENTIFIER_TYPENAME_P (name)
12108               || name == ansi_opname[(int) CALL_EXPR]
12109               || name == ansi_opname[(int) MODIFY_EXPR]
12110               || name == ansi_opname[(int) COMPONENT_REF]
12111               || name == ansi_opname[(int) ARRAY_REF])
12112             cp_error ("`%D' must be a nonstatic member function", decl);
12113           else
12114             {
12115               tree p = argtypes;
12116
12117               if (DECL_STATIC_FUNCTION_P (decl))
12118                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12119
12120               if (p)
12121                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12122                   {
12123                     tree arg = TREE_VALUE (p);
12124                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12125                       arg = TREE_TYPE (arg);
12126
12127                     /* This lets bad template code slip through.  */
12128                     if (IS_AGGR_TYPE (arg)
12129                         || TREE_CODE (arg) == ENUMERAL_TYPE
12130                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12131                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12132                       goto foundaggr;
12133                   }
12134               cp_error
12135                 ("`%D' must have an argument of class or enumerated type",
12136                  decl);
12137             foundaggr:
12138               ;
12139             }
12140         }
12141
12142       if (name == ansi_opname[(int) CALL_EXPR])
12143         return;                 /* No restrictions on args. */
12144
12145       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12146         {
12147           tree t = TREE_TYPE (name);
12148           if (! friendp)
12149             {
12150               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12151               const char *what = 0;
12152
12153               if (ref)
12154                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12155
12156               if (TREE_CODE (t) == VOID_TYPE)
12157                 what = "void";
12158               else if (t == current_class_type)
12159                 what = "the same type";
12160               /* Don't force t to be complete here.  */
12161               else if (IS_AGGR_TYPE (t)
12162                        && COMPLETE_TYPE_P (t)
12163                        && DERIVED_FROM_P (t, current_class_type))
12164                 what = "a base class";
12165
12166               if (what)
12167                 warning ("conversion to %s%s will never use a type conversion operator",
12168                          ref ? "a reference to " : "", what);
12169             }
12170         }
12171
12172       if (name == ansi_opname[(int) MODIFY_EXPR])
12173         {
12174           tree parmtype;
12175
12176           if (list_length (argtypes) != 3 && methodp)
12177             {
12178               cp_error ("`%D' must take exactly one argument", decl);
12179               return;
12180             }
12181           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12182
12183           if (copy_assignment_arg_p (parmtype, virtualp)
12184               && ! friendp)
12185             {
12186               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12187               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12188                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12189                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12190             }
12191         }
12192       else if (name == ansi_opname[(int) COND_EXPR])
12193         {
12194           /* 13.4.0.3 */
12195           cp_error ("ISO C++ prohibits overloading operator ?:");
12196         }
12197       else if (ambi_op_p (name))
12198         {
12199           if (list_length (argtypes) == 2)
12200             /* prefix */;
12201           else if (list_length (argtypes) == 3)
12202             {
12203               if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
12204                    || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12205                   && ! processing_template_decl
12206                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12207                 {
12208                   if (methodp)
12209                     cp_error ("postfix `%D' must take `int' as its argument",
12210                               decl);
12211                   else
12212                     cp_error
12213                       ("postfix `%D' must take `int' as its second argument",
12214                        decl);
12215                 }
12216             }
12217           else
12218             {
12219               if (methodp)
12220                 cp_error ("`%D' must take either zero or one argument", decl);
12221               else
12222                 cp_error ("`%D' must take either one or two arguments", decl);
12223             }
12224
12225           /* More Effective C++ rule 6.  */
12226           if (warn_ecpp
12227               && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12228                   || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
12229             {
12230               tree arg = TREE_VALUE (argtypes);
12231               tree ret = TREE_TYPE (TREE_TYPE (decl));
12232               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12233                 arg = TREE_TYPE (arg);
12234               arg = TYPE_MAIN_VARIANT (arg);
12235               if (list_length (argtypes) == 2)
12236                 {
12237                   if (TREE_CODE (ret) != REFERENCE_TYPE
12238                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12239                                        arg))
12240                     cp_warning ("prefix `%D' should return `%T'", decl,
12241                                 build_reference_type (arg));
12242                 }
12243               else
12244                 {
12245                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12246                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12247                 }
12248             }
12249         }
12250       else if (unary_op_p (name))
12251         {
12252           if (list_length (argtypes) != 2)
12253             {
12254               if (methodp)
12255                 cp_error ("`%D' must take `void'", decl);
12256               else
12257                 cp_error ("`%D' must take exactly one argument", decl);
12258             }
12259         }
12260       else /* if (binary_op_p (name)) */
12261         {
12262           if (list_length (argtypes) != 3)
12263             {
12264               if (methodp)
12265                 cp_error ("`%D' must take exactly one argument", decl);
12266               else
12267                 cp_error ("`%D' must take exactly two arguments", decl);
12268             }
12269
12270           /* More Effective C++ rule 7.  */
12271           if (warn_ecpp
12272               && (name == ansi_opname [TRUTH_ANDIF_EXPR]
12273                   || name == ansi_opname [TRUTH_ORIF_EXPR]
12274                   || name == ansi_opname [COMPOUND_EXPR]))
12275             cp_warning ("user-defined `%D' always evaluates both arguments",
12276                         decl);
12277         }
12278
12279       /* Effective C++ rule 23.  */
12280       if (warn_ecpp
12281           && list_length (argtypes) == 3
12282           && (name == ansi_opname [PLUS_EXPR]
12283               || name == ansi_opname [MINUS_EXPR]
12284               || name == ansi_opname [TRUNC_DIV_EXPR]
12285               || name == ansi_opname [MULT_EXPR])
12286           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12287         cp_warning ("`%D' should return by value", decl);
12288
12289       /* 13.4.0.8 */
12290       if (argtypes)
12291         for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
12292           if (TREE_PURPOSE (argtypes))
12293             {
12294               TREE_PURPOSE (argtypes) = NULL_TREE;
12295               if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12296                   || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12297                 {
12298                   if (pedantic)
12299                     cp_pedwarn ("`%D' cannot have default arguments", decl);
12300                 }
12301               else
12302                 cp_error ("`%D' cannot have default arguments", decl);
12303             }
12304     }
12305 }
12306 \f
12307 static const char *
12308 tag_name (code)
12309      enum tag_types code;
12310 {
12311   switch (code)
12312     {
12313     case record_type:
12314       return "struct";
12315     case class_type:
12316       return "class";
12317     case union_type:
12318       return "union ";
12319     case enum_type:
12320       return "enum";
12321     default:
12322       my_friendly_abort (981122);
12323     }
12324 }
12325
12326 /* Get the struct, enum or union (CODE says which) with tag NAME.
12327    Define the tag as a forward-reference if it is not defined.
12328
12329    C++: If a class derivation is given, process it here, and report
12330    an error if multiple derivation declarations are not identical.
12331
12332    If this is a definition, come in through xref_tag and only look in
12333    the current frame for the name (since C++ allows new names in any
12334    scope.)  */
12335
12336 tree
12337 xref_tag (code_type_node, name, globalize)
12338      tree code_type_node;
12339      tree name;
12340      int globalize;
12341 {
12342   enum tag_types tag_code;
12343   enum tree_code code;
12344   register tree ref, t;
12345   struct binding_level *b = current_binding_level;
12346   int got_type = 0;
12347   tree attributes = NULL_TREE;
12348   tree context = NULL_TREE;
12349
12350   /* If we are called from the parser, code_type_node will sometimes be a
12351      TREE_LIST.  This indicates that the user wrote
12352      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12353      use them later.  */
12354   if (TREE_CODE (code_type_node) == TREE_LIST)
12355     {
12356       attributes = TREE_PURPOSE (code_type_node);
12357       code_type_node = TREE_VALUE (code_type_node);
12358     }
12359
12360   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12361   switch (tag_code)
12362     {
12363     case record_type:
12364     case class_type:
12365       code = RECORD_TYPE;
12366       break;
12367     case union_type:
12368       code = UNION_TYPE;
12369       break;
12370     case enum_type:
12371       code = ENUMERAL_TYPE;
12372       break;
12373     default:
12374       my_friendly_abort (18);
12375     }
12376
12377   /* If a cross reference is requested, look up the type
12378      already defined for this tag and return it.  */
12379   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
12380     {
12381       t = name;
12382       name = TYPE_IDENTIFIER (t);
12383       got_type = 1;
12384     }
12385   else
12386     t = IDENTIFIER_TYPE_VALUE (name);
12387
12388   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12389       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12390     t = NULL_TREE;
12391
12392   if (! globalize)
12393     {
12394       /* If we know we are defining this tag, only look it up in
12395          this scope and don't try to find it as a type.  */
12396       ref = lookup_tag (code, name, b, 1);
12397     }
12398   else
12399     {
12400       if (t)
12401         {
12402           /* [dcl.type.elab] If the identifier resolves to a
12403              typedef-name or a template type-parameter, the
12404              elaborated-type-specifier is ill-formed.  */
12405           if (t != TYPE_MAIN_VARIANT (t)
12406               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12407             cp_pedwarn ("using typedef-name `%D' after `%s'",
12408                         TYPE_NAME (t), tag_name (tag_code));
12409           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12410             cp_error ("using template type parameter `%T' after `%s'",
12411                       t, tag_name (tag_code));
12412
12413           ref = t;
12414         }
12415       else
12416         ref = lookup_tag (code, name, b, 0);
12417
12418       if (! ref)
12419         {
12420           /* Try finding it as a type declaration.  If that wins,
12421              use it.  */
12422           ref = lookup_name (name, 1);
12423
12424           if (ref != NULL_TREE
12425               && processing_template_decl
12426               && DECL_CLASS_TEMPLATE_P (ref)
12427               && template_class_depth (current_class_type) == 0)
12428             /* Since GLOBALIZE is true, we're declaring a global
12429                template, so we want this type.  */
12430             ref = DECL_RESULT (ref);
12431
12432           if (ref && TREE_CODE (ref) == TYPE_DECL
12433               && TREE_CODE (TREE_TYPE (ref)) == code)
12434             ref = TREE_TYPE (ref);
12435           else
12436             ref = NULL_TREE;
12437         }
12438
12439       if (ref && current_class_type
12440           && template_class_depth (current_class_type)
12441           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12442         {
12443           /* Since GLOBALIZE is non-zero, we are not looking at a
12444              definition of this tag.  Since, in addition, we are currently
12445              processing a (member) template declaration of a template
12446              class, we must be very careful; consider:
12447
12448                template <class X>
12449                struct S1
12450
12451                template <class U>
12452                struct S2
12453                { template <class V>
12454                friend struct S1; };
12455
12456              Here, the S2::S1 declaration should not be confused with the
12457              outer declaration.  In particular, the inner version should
12458              have a template parameter of level 2, not level 1.  This
12459              would be particularly important if the member declaration
12460              were instead:
12461
12462                template <class V = U> friend struct S1;
12463
12464              say, when we should tsubst into `U' when instantiating
12465              S2.  On the other hand, when presented with:
12466
12467                  template <class T>
12468                  struct S1 {
12469                    template <class U>
12470                    struct S2 {};
12471                    template <class U>
12472                    friend struct S2;
12473                  };
12474
12475               we must find the inner binding eventually.  We
12476               accomplish this by making sure that the new type we
12477               create to represent this declaration has the right
12478               TYPE_CONTEXT.  */
12479           context = TYPE_CONTEXT (ref);
12480           ref = NULL_TREE;
12481         }
12482     }
12483
12484   if (! ref)
12485     {
12486       /* If no such tag is yet defined, create a forward-reference node
12487          and record it as the "definition".
12488          When a real declaration of this type is found,
12489          the forward-reference will be altered into a real type.  */
12490       if (code == ENUMERAL_TYPE)
12491         {
12492           cp_error ("use of enum `%#D' without previous declaration", name);
12493
12494           ref = make_node (ENUMERAL_TYPE);
12495
12496           /* Give the type a default layout like unsigned int
12497              to avoid crashing if it does not get defined.  */
12498           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12499           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12500           TREE_UNSIGNED (ref) = 1;
12501           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12502           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12503           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12504
12505           /* Enable us to recognize when a type is created in class context.
12506              To do nested classes correctly, this should probably be cleared
12507              out when we leave this classes scope.  Currently this in only
12508              done in `start_enum'.  */
12509
12510           pushtag (name, ref, globalize);
12511         }
12512       else
12513         {
12514           struct binding_level *old_b = class_binding_level;
12515
12516           ref = make_aggr_type (code);
12517           TYPE_CONTEXT (ref) = context;
12518
12519 #ifdef NONNESTED_CLASSES
12520           /* Class types don't nest the way enums do.  */
12521           class_binding_level = (struct binding_level *)0;
12522 #endif
12523           pushtag (name, ref, globalize);
12524           class_binding_level = old_b;
12525         }
12526     }
12527   else
12528     {
12529       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12530         redeclare_class_template (ref, current_template_parms);
12531     }
12532
12533   /* Until the type is defined, tentatively accept whatever
12534      structure tag the user hands us.  */
12535   if (!COMPLETE_TYPE_P (ref)
12536       && ref != current_class_type
12537       /* Have to check this, in case we have contradictory tag info.  */
12538       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12539     {
12540       if (tag_code == class_type)
12541         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12542       else if (tag_code == record_type)
12543         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12544     }
12545
12546   TREE_TYPE (ref) = attributes;
12547
12548   return ref;
12549 }
12550
12551 tree
12552 xref_tag_from_type (old, id, globalize)
12553      tree old, id;
12554      int globalize;
12555 {
12556   tree code_type_node;
12557
12558   if (TREE_CODE (old) == RECORD_TYPE)
12559     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12560                       ? class_type_node : record_type_node);
12561   else
12562     code_type_node = union_type_node;
12563
12564   if (id == NULL_TREE)
12565     id = TYPE_IDENTIFIER (old);
12566
12567   return xref_tag (code_type_node, id, globalize);
12568 }
12569
12570 /* REF is a type (named NAME), for which we have just seen some
12571    baseclasses.  BINFO is a list of those baseclasses; the
12572    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12573    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12574    struct, or union.  */
12575
12576 void
12577 xref_basetypes (code_type_node, name, ref, binfo)
12578      tree code_type_node;
12579      tree name, ref;
12580      tree binfo;
12581 {
12582   /* In the declaration `A : X, Y, ... Z' we mark all the types
12583      (A, X, Y, ..., Z) so we can check for duplicates.  */
12584   tree binfos;
12585   tree base;
12586
12587   int i, len;
12588   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12589
12590   if (tag_code == union_type)
12591     {
12592       cp_error ("derived union `%T' invalid", ref);
12593       return;
12594     }
12595
12596   len = list_length (binfo);
12597
12598   /* First, make sure that any templates in base-classes are
12599      instantiated.  This ensures that if we call ourselves recursively
12600      we do not get confused about which classes are marked and which
12601      are not.  */
12602   for (base = binfo; base; base = TREE_CHAIN (base))
12603     complete_type (TREE_VALUE (base));
12604
12605   SET_CLASSTYPE_MARKED (ref);
12606   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12607
12608   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12609     {
12610       /* The base of a derived struct is public by default.  */
12611       int via_public
12612         = (TREE_PURPOSE (binfo) == access_public_node
12613            || TREE_PURPOSE (binfo) == access_public_virtual_node
12614            || (tag_code != class_type
12615                && (TREE_PURPOSE (binfo) == access_default_node
12616                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12617       int via_protected
12618         = (TREE_PURPOSE (binfo) == access_protected_node
12619            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12620       int via_virtual
12621         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12622            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12623            || TREE_PURPOSE (binfo) == access_public_virtual_node
12624            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12625       tree basetype = TREE_VALUE (binfo);
12626       tree base_binfo;
12627
12628       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12629         basetype = TREE_TYPE (basetype);
12630       if (!basetype
12631           || (TREE_CODE (basetype) != RECORD_TYPE
12632               && TREE_CODE (basetype) != TYPENAME_TYPE
12633               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12634               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12635         {
12636           cp_error ("base type `%T' fails to be a struct or class type",
12637                     TREE_VALUE (binfo));
12638           continue;
12639         }
12640
12641       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12642
12643       /* This code replaces similar code in layout_basetypes.
12644          We put the complete_type first for implicit `typename'.  */
12645       if (!COMPLETE_TYPE_P (basetype)
12646           && ! (current_template_parms && uses_template_parms (basetype)))
12647         {
12648           cp_error ("base class `%T' has incomplete type", basetype);
12649           continue;
12650         }
12651       else
12652         {
12653           if (CLASSTYPE_MARKED (basetype))
12654             {
12655               if (basetype == ref)
12656                 cp_error ("recursive type `%T' undefined", basetype);
12657               else
12658                 cp_error ("duplicate base type `%T' invalid", basetype);
12659               continue;
12660             }
12661
12662           if (TYPE_FOR_JAVA (basetype)
12663               && (current_lang_stack
12664                   == &VARRAY_TREE (current_lang_base, 0)))
12665             TYPE_FOR_JAVA (ref) = 1;
12666
12667           /* Note that the BINFO records which describe individual
12668              inheritances are *not* shared in the lattice!  They
12669              cannot be shared because a given baseclass may be
12670              inherited with different `accessibility' by different
12671              derived classes.  (Each BINFO record describing an
12672              individual inheritance contains flags which say what
12673              the `accessibility' of that particular inheritance is.)  */
12674
12675           base_binfo
12676             = make_binfo (size_zero_node, basetype,
12677                           CLASS_TYPE_P (basetype)
12678                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12679                           CLASS_TYPE_P (basetype)
12680                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12681
12682           TREE_VEC_ELT (binfos, i) = base_binfo;
12683           TREE_VIA_PUBLIC (base_binfo) = via_public;
12684           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12685           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12686           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12687
12688           /* We need to unshare the binfos now so that lookups during class
12689              definition work.  */
12690           unshare_base_binfos (base_binfo);
12691
12692           SET_CLASSTYPE_MARKED (basetype);
12693
12694           /* We are free to modify these bits because they are meaningless
12695              at top level, and BASETYPE is a top-level type.  */
12696           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12697             {
12698               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12699               /* Converting to a virtual base class requires looking
12700                  up the offset of the virtual base.  */
12701               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12702             }
12703
12704           if (CLASS_TYPE_P (basetype))
12705             {
12706               TYPE_HAS_NEW_OPERATOR (ref)
12707                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12708               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12709                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12710               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12711               /* If the base-class uses multiple inheritance, so do we.  */
12712               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12713                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12714               /* Likewise, if converting to a base of the base may require
12715                  code, then we may need to generate code to convert to a
12716                  base as well.  */
12717               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12718                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12719             }
12720
12721           i += 1;
12722         }
12723     }
12724   if (i)
12725     TREE_VEC_LENGTH (binfos) = i;
12726   else
12727     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12728
12729   if (i > 1)
12730     {
12731       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12732       /* If there is more than one non-empty they cannot be at the same
12733          address.  */
12734       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12735     }
12736
12737   /* Unmark all the types.  */
12738   while (--i >= 0)
12739     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12740   CLEAR_CLASSTYPE_MARKED (ref);
12741
12742   /* Now that we know all the base-classes, set up the list of virtual
12743      bases.  */
12744   get_vbase_types (ref);
12745 }
12746
12747 \f
12748 /* Begin compiling the definition of an enumeration type.
12749    NAME is its name (or null if anonymous).
12750    Returns the type object, as yet incomplete.
12751    Also records info about it so that build_enumerator
12752    may be used to declare the individual values as they are read.  */
12753
12754 tree
12755 start_enum (name)
12756      tree name;
12757 {
12758   register tree enumtype = NULL_TREE;
12759   struct binding_level *b = current_binding_level;
12760
12761   /* If this is the real definition for a previous forward reference,
12762      fill in the contents in the same object that used to be the
12763      forward reference.  */
12764
12765   if (name != NULL_TREE)
12766     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12767
12768   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12769     {
12770       cp_error ("multiple definition of `%#T'", enumtype);
12771       cp_error_at ("previous definition here", enumtype);
12772       /* Clear out TYPE_VALUES, and start again.  */
12773       TYPE_VALUES (enumtype) = NULL_TREE;
12774     }
12775   else
12776     {
12777       enumtype = make_node (ENUMERAL_TYPE);
12778       pushtag (name, enumtype, 0);
12779     }
12780
12781   if (current_class_type)
12782     TREE_ADDRESSABLE (b->tags) = 1;
12783
12784   GNU_xref_decl (current_function_decl, enumtype);
12785   return enumtype;
12786 }
12787
12788 /* After processing and defining all the values of an enumeration type,
12789    install their decls in the enumeration type and finish it off.
12790    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12791    Returns ENUMTYPE.  */
12792
12793 tree
12794 finish_enum (enumtype)
12795      tree enumtype;
12796 {
12797   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12798   /* Calculate the maximum value of any enumerator in this type.  */
12799
12800   tree values = TYPE_VALUES (enumtype);
12801   if (values)
12802     {
12803       tree pair;
12804
12805       for (pair = values; pair; pair = TREE_CHAIN (pair))
12806         {
12807           tree decl;
12808           tree value;
12809
12810           /* The TREE_VALUE is a CONST_DECL for this enumeration
12811              constant.  */
12812           decl = TREE_VALUE (pair);
12813
12814           /* [dcl.enum]
12815
12816              Following the closing brace of an enum-specifier, each
12817              enumerator has the type of its enumeration.  Prior to the
12818              closing brace, the type of each enumerator is the type of
12819              its initializing value.  */
12820           TREE_TYPE (decl) = enumtype;
12821
12822           /* The DECL_INITIAL will be NULL if we are processing a
12823              template declaration and this enumeration constant had no
12824              explicit initializer.  */
12825           value = DECL_INITIAL (decl);
12826           if (value && !processing_template_decl)
12827             {
12828               /* Set the TREE_TYPE for the VALUE as well.  That's so
12829                  that when we call decl_constant_value we get an
12830                  entity of the right type (but with the constant
12831                  value).  Since we shouldn't ever call
12832                  decl_constant_value on a template type, there's no
12833                  reason to do that when processing_template_decl.
12834                  And, if the expression is something like a
12835                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12836                  wreak havoc on the intended type of the expression.
12837
12838                  Of course, there's also no point in trying to compute
12839                  minimum or maximum values if we're in a template.  */
12840               TREE_TYPE (value) = enumtype;
12841
12842               if (!minnode)
12843                 minnode = maxnode = value;
12844               else if (tree_int_cst_lt (maxnode, value))
12845                 maxnode = value;
12846               else if (tree_int_cst_lt (value, minnode))
12847                 minnode = value;
12848             }
12849
12850           if (processing_template_decl)
12851             /* If this is just a template, leave the CONST_DECL
12852                alone.  That way tsubst_copy will find CONST_DECLs for
12853                CONST_DECLs, and not INTEGER_CSTs.  */
12854             ;
12855           else
12856             /* In the list we're building up, we want the enumeration
12857                values, not the CONST_DECLs.  */
12858             TREE_VALUE (pair) = value;
12859         }
12860     }
12861   else
12862     maxnode = minnode = integer_zero_node;
12863
12864   TYPE_VALUES (enumtype) = nreverse (values);
12865
12866   if (processing_template_decl)
12867     {
12868       tree scope = current_scope ();
12869       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12870         add_tree (build_min (TAG_DEFN, enumtype));
12871     }
12872   else
12873     {
12874       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12875       int lowprec = min_precision (minnode, unsignedp);
12876       int highprec = min_precision (maxnode, unsignedp);
12877       int precision = MAX (lowprec, highprec);
12878       tree tem;
12879
12880       TYPE_SIZE (enumtype) = NULL_TREE;
12881
12882       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12883
12884       TYPE_PRECISION (enumtype) = precision;
12885       if (unsignedp)
12886         fixup_unsigned_type (enumtype);
12887       else
12888         fixup_signed_type (enumtype);
12889
12890       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12891         /* Use the width of the narrowest normal C type which is wide
12892            enough.  */
12893         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12894                                                     (precision, 1));
12895       else
12896         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12897
12898       TYPE_SIZE (enumtype) = 0;
12899       layout_type (enumtype);
12900
12901       /* Fix up all variant types of this enum type.  */
12902       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12903            tem = TYPE_NEXT_VARIANT (tem))
12904         {
12905           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12906           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12907           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12908           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12909           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12910           TYPE_MODE (tem) = TYPE_MODE (enumtype);
12911           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12912           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12913           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12914         }
12915
12916       /* Finish debugging output for this type.  */
12917       rest_of_type_compilation (enumtype, namespace_bindings_p ());
12918     }
12919
12920   return enumtype;
12921 }
12922
12923 /* Build and install a CONST_DECL for an enumeration constant of the
12924    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12925    Assignment of sequential values by default is handled here.  */
12926
12927 void
12928 build_enumerator (name, value, enumtype)
12929      tree name;
12930      tree value;
12931      tree enumtype;
12932 {
12933   tree decl;
12934   tree context;
12935   tree type;
12936   tree values;
12937
12938   /* Remove no-op casts from the value.  */
12939   if (value)
12940     STRIP_TYPE_NOPS (value);
12941
12942   if (! processing_template_decl)
12943     {
12944       /* Validate and default VALUE.  */
12945       if (value != NULL_TREE)
12946         {
12947           if (TREE_READONLY_DECL_P (value))
12948             value = decl_constant_value (value);
12949
12950           if (TREE_CODE (value) == INTEGER_CST)
12951             {
12952               value = default_conversion (value);
12953               constant_expression_warning (value);
12954             }
12955           else
12956             {
12957               cp_error ("enumerator value for `%D' not integer constant", name);
12958               value = NULL_TREE;
12959             }
12960         }
12961
12962       /* Default based on previous value.  */
12963       if (value == NULL_TREE && ! processing_template_decl)
12964         {
12965           tree prev_value;
12966
12967           if (TYPE_VALUES (enumtype))
12968             {
12969               /* The next value is the previous value ... */
12970               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
12971               /* ... plus one.  */
12972               value = build_binary_op (PLUS_EXPR,
12973                                        prev_value,
12974                                        integer_one_node);
12975
12976               if (tree_int_cst_lt (value, prev_value))
12977                 cp_error ("overflow in enumeration values at `%D'", name);
12978             }
12979           else
12980             value = integer_zero_node;
12981         }
12982
12983       /* Remove no-op casts from the value.  */
12984       if (value)
12985         STRIP_TYPE_NOPS (value);
12986 #if 0
12987       /* To fix MAX_VAL enum consts. (bkoz)  */
12988       TREE_TYPE (value) = integer_type_node;
12989 #endif
12990     }
12991
12992   /* We always have to copy here; not all INTEGER_CSTs are unshared.
12993      Even in other cases, we will later (in finish_enum) be setting
12994      the type of VALUE.  But, we don't need to make a copy if this
12995      VALUE is one of the enumeration constants for this same
12996      enumeration type.  */
12997   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
12998     if (TREE_VALUE (values) == value)
12999       break;
13000   /* If we didn't break out of the loop, then we do need a copy.  */
13001   if (!values && value)
13002     value = copy_node (value);
13003
13004   /* C++ associates enums with global, function, or class declarations.  */
13005   context = current_scope ();
13006
13007   /* Build the actual enumeration constant.  Note that the enumeration
13008     constants have the type of their initializers until the
13009     enumeration is complete:
13010
13011       [ dcl.enum ]
13012
13013       Following the closing brace of an enum-specifier, each enumer-
13014       ator has the type of its enumeration.  Prior to the closing
13015       brace, the type of each enumerator is the type of its
13016       initializing value.
13017
13018     In finish_enum we will reset the type.  Of course, if we're
13019     processing a template, there may be no value.   */
13020   type = value ? TREE_TYPE (value) : NULL_TREE;
13021
13022   if (context && context == current_class_type)
13023     /* This enum declaration is local to the class.  We need the full
13024       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13025     decl = build_lang_decl (CONST_DECL, name, type);
13026   else
13027     /* It's a global enum, or it's local to a function.  (Note local to
13028       a function could mean local to a class method.  */
13029     decl = build_decl (CONST_DECL, name, type);
13030
13031   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13032   DECL_INITIAL (decl) = value;
13033   TREE_READONLY (decl) = 1;
13034
13035   if (context && context == current_class_type)
13036     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13037       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13038       things like `S::i' later.)  */
13039     finish_member_declaration (decl);
13040   else
13041     {
13042       pushdecl (decl);
13043       GNU_xref_decl (current_function_decl, decl);
13044     }
13045
13046   /* Add this enumeration constant to the list for this type.  */
13047   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13048 }
13049
13050 \f
13051 static int function_depth;
13052
13053 /* We're defining DECL.  Make sure that it's type is OK.  */
13054
13055 static void
13056 check_function_type (decl)
13057      tree decl;
13058 {
13059   tree fntype = TREE_TYPE (decl);
13060   tree return_type = complete_type (TREE_TYPE (fntype));
13061
13062   /* In a function definition, arg types must be complete.  */
13063   require_complete_types_for_parms (current_function_parms);
13064
13065   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13066     {
13067       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13068
13069       /* Make it return void instead, but don't change the
13070          type of the DECL_RESULT, in case we have a named return value.  */
13071       if (TREE_CODE (fntype) == METHOD_TYPE)
13072         {
13073           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13074           TREE_TYPE (decl)
13075             = build_cplus_method_type (ctype,
13076                                        void_type_node,
13077                                        FUNCTION_ARG_CHAIN (decl));
13078         }
13079       else
13080         TREE_TYPE (decl)
13081           = build_function_type (void_type_node,
13082                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13083       TREE_TYPE (decl)
13084         = build_exception_variant (fntype,
13085                                    TYPE_RAISES_EXCEPTIONS (fntype));
13086     }
13087   else
13088     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13089 }
13090
13091 /* Create the FUNCTION_DECL for a function definition.
13092    DECLSPECS and DECLARATOR are the parts of the declaration;
13093    they describe the function's name and the type it returns,
13094    but twisted together in a fashion that parallels the syntax of C.
13095
13096    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13097    DECLARATOR is really the DECL for the function we are about to
13098    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13099    indicating that the function is an inline defined in-class, and
13100    SF_EXPAND indicating that we should generate RTL for this
13101    function.
13102
13103    This function creates a binding context for the function body
13104    as well as setting up the FUNCTION_DECL in current_function_decl.
13105
13106    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13107    (it defines a datum instead), we return 0, which tells
13108    yyparse to report a parse error.
13109
13110    For C++, we must first check whether that datum makes any sense.
13111    For example, "class A local_a(1,2);" means that variable local_a
13112    is an aggregate of type A, which should have a constructor
13113    applied to it with the argument list [1, 2].  */
13114
13115 int
13116 start_function (declspecs, declarator, attrs, flags)
13117      tree declspecs, declarator, attrs;
13118      int flags;
13119 {
13120   tree decl1;
13121   tree ctype = NULL_TREE;
13122   tree fntype;
13123   tree restype;
13124   extern int have_extern_spec;
13125   extern int used_extern_spec;
13126   int doing_friend = 0;
13127   struct binding_level *bl;
13128
13129   /* Sanity check.  */
13130   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13131   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13132
13133   /* This should only be done once on the top most decl.  */
13134   if (have_extern_spec && !used_extern_spec)
13135     {
13136       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13137       used_extern_spec = 1;
13138     }
13139
13140   if (flags & SF_PRE_PARSED)
13141     {
13142       decl1 = declarator;
13143
13144       fntype = TREE_TYPE (decl1);
13145       if (TREE_CODE (fntype) == METHOD_TYPE)
13146         ctype = TYPE_METHOD_BASETYPE (fntype);
13147
13148       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13149          the (lexical) scope of the class in which it is defined.  */
13150       if (!ctype && DECL_FRIEND_P (decl1))
13151         {
13152           ctype = DECL_FRIEND_CONTEXT (decl1);
13153
13154           /* CTYPE could be null here if we're dealing with a template;
13155              for example, `inline friend float foo()' inside a template
13156              will have no CTYPE set.  */
13157           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13158             ctype = NULL_TREE;
13159           else
13160             doing_friend = 1;
13161         }
13162
13163       last_function_parms = DECL_ARGUMENTS (decl1);
13164       last_function_parm_tags = NULL_TREE;
13165     }
13166   else
13167     {
13168       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13169       /* If the declarator is not suitable for a function definition,
13170          cause a syntax error.  */
13171       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13172
13173       fntype = TREE_TYPE (decl1);
13174
13175       restype = TREE_TYPE (fntype);
13176       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13177         {
13178           cp_error ("semicolon missing after declaration of `%#T'", restype);
13179           shadow_tag (build_tree_list (NULL_TREE, restype));
13180           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13181           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13182             fntype = build_function_type (integer_type_node,
13183                                           TYPE_ARG_TYPES (fntype));
13184           else
13185             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13186                                               integer_type_node,
13187                                               TYPE_ARG_TYPES (fntype));
13188           TREE_TYPE (decl1) = fntype;
13189         }
13190
13191       if (TREE_CODE (fntype) == METHOD_TYPE)
13192         ctype = TYPE_METHOD_BASETYPE (fntype);
13193       else if (DECL_MAIN_P (decl1))
13194         {
13195           /* If this doesn't return integer_type, complain.  */
13196           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13197             {
13198               if (pedantic || warn_return_type)
13199                 pedwarn ("return type for `main' changed to `int'");
13200               TREE_TYPE (decl1) = fntype = default_function_type;
13201             }
13202         }
13203     }
13204
13205   /* Sometimes we don't notice that a function is a static member, and
13206      build a METHOD_TYPE for it.  Fix that up now.  */
13207   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13208       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13209     {
13210       revert_static_member_fn (decl1);
13211       last_function_parms = TREE_CHAIN (last_function_parms);
13212       ctype = NULL_TREE;
13213     }
13214
13215   /* Warn if function was previously implicitly declared
13216      (but not if we warned then).  */
13217   if (! warn_implicit
13218       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13219     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13220
13221   /* Set up current_class_type, and enter the scope of the class, if
13222      appropriate.  */
13223   if (ctype)
13224     push_nested_class (ctype, 1);
13225   else if (DECL_STATIC_FUNCTION_P (decl1))
13226     push_nested_class (DECL_CONTEXT (decl1), 2);
13227
13228   /* Now that we have entered the scope of the class, we must restore
13229      the bindings for any template parameters surrounding DECL1, if it
13230      is an inline member template.  (Order is important; consider the
13231      case where a template parameter has the same name as a field of
13232      the class.)  It is not until after this point that
13233      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13234   if (flags & SF_INCLASS_INLINE)
13235     maybe_begin_member_template_processing (decl1);
13236
13237   /* Effective C++ rule 15.  See also c_expand_return.  */
13238   if (warn_ecpp
13239       && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
13240       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13241     cp_warning ("`operator=' should return a reference to `*this'");
13242
13243   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13244      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13245   if (!DECL_INITIAL (decl1))
13246     DECL_INITIAL (decl1) = error_mark_node;
13247
13248 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13249   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13250 #endif
13251
13252   /* This function exists in static storage.
13253      (This does not mean `static' in the C sense!)  */
13254   TREE_STATIC (decl1) = 1;
13255
13256   /* We must call push_template_decl after current_class_type is set
13257      up.  (If we are processing inline definitions after exiting a
13258      class scope, current_class_type will be NULL_TREE until set above
13259      by push_nested_class.)  */
13260   if (processing_template_decl)
13261     decl1 = push_template_decl (decl1);
13262
13263   /* We are now in the scope of the function being defined.  */
13264   current_function_decl = decl1;
13265
13266   /* Save the parm names or decls from this function's declarator
13267      where store_parm_decls will find them.  */
13268   current_function_parms = last_function_parms;
13269   current_function_parm_tags = last_function_parm_tags;
13270
13271   /* Make sure the parameter and return types are reasonable.  When
13272      you declare a function, these types can be incomplete, but they
13273      must be complete when you define the function.  */
13274   if (! processing_template_decl)
13275     check_function_type (decl1);
13276
13277   /* Build the return declaration for the function.  */
13278   restype = TREE_TYPE (fntype);
13279   if (!processing_template_decl)
13280     {
13281       if (!DECL_RESULT (decl1))
13282         {
13283           DECL_RESULT (decl1)
13284             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13285           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13286                                       DECL_RESULT (decl1));
13287         }
13288     }
13289   else
13290     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13291     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13292
13293   /* Initialize RTL machinery.  We cannot do this until
13294      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13295      even when processing a template; this is how we get
13296      CFUN set up, and our per-function variables initialized.  */
13297   bl = current_binding_level;
13298   init_function_start (decl1, input_filename, lineno);
13299   current_binding_level = bl;
13300   expanding_p = (flags & SF_EXPAND) != 0;
13301
13302   /* Even though we're inside a function body, we still don't want to
13303      call expand_expr to calculate the size of a variable-sized array.
13304      We haven't necessarily assigned RTL to all variables yet, so it's
13305      not safe to try to expand expressions involving them.  */
13306   immediate_size_expand = 0;
13307   cfun->x_dont_save_pending_sizes_p = 1;
13308
13309   /* If we're building a statement-tree, start the tree now.  */
13310   if (processing_template_decl || !expanding_p)
13311     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13312
13313   /* Let the user know we're compiling this function.  */
13314   if (processing_template_decl || !building_stmt_tree ())
13315     announce_function (decl1);
13316
13317   /* Record the decl so that the function name is defined.
13318      If we already have a decl for this name, and it is a FUNCTION_DECL,
13319      use the old decl.  */
13320   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13321     {
13322       /* A specialization is not used to guide overload resolution.  */
13323       if ((flag_guiding_decls
13324            || !DECL_TEMPLATE_SPECIALIZATION (decl1))
13325           && ! DECL_FUNCTION_MEMBER_P (decl1))
13326         decl1 = pushdecl (decl1);
13327       else
13328         {
13329           /* We need to set the DECL_CONTEXT. */
13330           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13331             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13332           /* And make sure we have enough default args.  */
13333           check_default_args (decl1);
13334         }
13335       DECL_MAIN_VARIANT (decl1) = decl1;
13336       fntype = TREE_TYPE (decl1);
13337     }
13338
13339   /* Reset these in case the call to pushdecl changed them.  */
13340   current_function_decl = decl1;
13341   cfun->decl = decl1;
13342
13343   /* Initialize the per-function data.  */
13344   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13345     {
13346       /* If we already parsed this function, and we're just expanding it
13347          now, restore saved state.  */
13348       struct binding_level *bl = current_binding_level;
13349       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13350       current_binding_level = bl;
13351
13352       /* This function is being processed in whole-function mode; we
13353          already did semantic analysis.  */
13354       cfun->x_whole_function_mode_p = 1;
13355
13356       /* If we decided that we didn't want to inline this function,
13357          make sure the back-end knows that.  */
13358       if (!current_function_cannot_inline)
13359         current_function_cannot_inline = cp_function_chain->cannot_inline;
13360
13361       /* We don't need the saved data anymore.  */
13362       free (DECL_SAVED_FUNCTION_DATA (decl1));
13363       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13364     }
13365   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13366     {
13367       /* We know that this was set up by `grokclassfn'.  We do not
13368          wait until `store_parm_decls', since evil parse errors may
13369          never get us to that point.  Here we keep the consistency
13370          between `current_class_type' and `current_class_ptr'.  */
13371       tree t = DECL_ARGUMENTS (decl1);
13372
13373       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13374                           162);
13375       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13376                           19990811);
13377
13378       cp_function_chain->x_current_class_ref
13379         = build_indirect_ref (t, NULL_PTR);
13380       cp_function_chain->x_current_class_ptr = t;
13381
13382       /* Constructors and destructors need to know whether they're "in
13383          charge" of initializing virtual base classes.  */
13384       if (DECL_DESTRUCTOR_P (decl1))
13385         current_in_charge_parm = TREE_CHAIN (t);
13386       else if (DECL_CONSTRUCTOR_P (decl1)
13387                && TREE_CHAIN (t)
13388                && DECL_ARTIFICIAL (TREE_CHAIN (t))
13389                && (DECL_NAME (TREE_CHAIN (t))
13390                    == in_charge_identifier))
13391         current_in_charge_parm = TREE_CHAIN (t);
13392     }
13393
13394   if (DECL_INTERFACE_KNOWN (decl1))
13395     {
13396       tree ctx = decl_function_context (decl1);
13397
13398       if (DECL_NOT_REALLY_EXTERN (decl1))
13399         DECL_EXTERNAL (decl1) = 0;
13400
13401       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13402           && TREE_PUBLIC (ctx))
13403         /* This is a function in a local class in an extern inline
13404            function.  */
13405         comdat_linkage (decl1);
13406     }
13407   /* If this function belongs to an interface, it is public.
13408      If it belongs to someone else's interface, it is also external.
13409      This only affects inlines and template instantiations.  */
13410   else if (interface_unknown == 0
13411            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13412                || flag_alt_external_templates))
13413     {
13414       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13415           || processing_template_decl)
13416         {
13417           DECL_EXTERNAL (decl1)
13418             = (interface_only
13419                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13420                    && !DECL_VINDEX (decl1)));
13421
13422           /* For WIN32 we also want to put these in linkonce sections.  */
13423           maybe_make_one_only (decl1);
13424         }
13425       else
13426         DECL_EXTERNAL (decl1) = 0;
13427       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13428       DECL_INTERFACE_KNOWN (decl1) = 1;
13429     }
13430   else if (interface_unknown && interface_only
13431            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13432                || flag_alt_external_templates))
13433     {
13434       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13435          interface, we will have interface_only set but not
13436          interface_known.  In that case, we don't want to use the normal
13437          heuristics because someone will supply a #pragma implementation
13438          elsewhere, and deducing it here would produce a conflict.  */
13439       comdat_linkage (decl1);
13440       DECL_EXTERNAL (decl1) = 0;
13441       DECL_INTERFACE_KNOWN (decl1) = 1;
13442       DECL_DEFER_OUTPUT (decl1) = 1;
13443     }
13444   else
13445     {
13446       /* This is a definition, not a reference.
13447          So clear DECL_EXTERNAL.  */
13448       DECL_EXTERNAL (decl1) = 0;
13449
13450       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13451           && ! DECL_INTERFACE_KNOWN (decl1)
13452           /* Don't try to defer nested functions for now.  */
13453           && ! decl_function_context (decl1))
13454         DECL_DEFER_OUTPUT (decl1) = 1;
13455       else
13456         DECL_INTERFACE_KNOWN (decl1) = 1;
13457     }
13458
13459   if (doing_semantic_analysis_p ())
13460     {
13461       pushlevel (0);
13462       current_binding_level->parm_flag = 1;
13463     }
13464
13465   if (attrs)
13466     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13467
13468   if (!building_stmt_tree ())
13469     {
13470       GNU_xref_function (decl1, current_function_parms);
13471       make_function_rtl (decl1);
13472     }
13473
13474   /* Promote the value to int before returning it.  */
13475   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13476     restype = type_promotes_to (restype);
13477
13478   /* If this fcn was already referenced via a block-scope `extern' decl
13479      (or an implicit decl), propagate certain information about the usage.  */
13480   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13481     TREE_ADDRESSABLE (decl1) = 1;
13482
13483   if (DECL_RESULT (decl1) == NULL_TREE)
13484     {
13485       DECL_RESULT (decl1)
13486         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13487       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13488       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13489     }
13490
13491   ++function_depth;
13492
13493   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
13494       && DECL_LANGUAGE (decl1) == lang_cplusplus)
13495     {
13496       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13497       DECL_CONTEXT (dtor_label) = current_function_decl;
13498     }
13499   else if (DECL_CONSTRUCTOR_P (decl1))
13500     {
13501       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13502       DECL_CONTEXT (ctor_label) = current_function_decl;
13503     }
13504
13505   return 1;
13506 }
13507 \f
13508 /* Called after store_parm_decls for a function-try-block.  */
13509
13510 void
13511 expand_start_early_try_stmts ()
13512 {
13513   expand_start_try_stmts ();
13514 }
13515
13516 /* Store the parameter declarations into the current function declaration.
13517    This is called after parsing the parameter declarations, before
13518    digesting the body of the function.
13519
13520    Also install to binding contour return value identifier, if any.  */
13521
13522 void
13523 store_parm_decls ()
13524 {
13525   register tree fndecl = current_function_decl;
13526   register tree parm;
13527   int parms_have_cleanups = 0;
13528   tree cleanups = NULL_TREE;
13529
13530   /* This is a list of types declared among parms in a prototype.  */
13531   tree parmtags = current_function_parm_tags;
13532
13533   /* This is a chain of any other decls that came in among the parm
13534      declarations.  If a parm is declared with  enum {foo, bar} x;
13535      then CONST_DECLs for foo and bar are put here.  */
13536   tree nonparms = NULL_TREE;
13537
13538   /* Create a binding level for the parms.  */
13539   if (!building_stmt_tree ())
13540     expand_start_bindings (2);
13541
13542   if (current_function_parms)
13543     {
13544       /* This case is when the function was defined with an ANSI prototype.
13545          The parms already have decls, so we need not do anything here
13546          except record them as in effect
13547          and complain if any redundant old-style parm decls were written.  */
13548
13549       tree specparms = current_function_parms;
13550       tree next;
13551
13552       if (doing_semantic_analysis_p ())
13553         {
13554           /* Must clear this because it might contain TYPE_DECLs declared
13555              at class level.  */
13556           storedecls (NULL_TREE);
13557
13558           /* If we're doing semantic analysis, then we'll call pushdecl
13559              for each of these.  We must do them in reverse order so that
13560              they end in the correct forward order.  */
13561           specparms = nreverse (specparms);
13562         }
13563
13564       for (parm = specparms; parm; parm = next)
13565         {
13566           next = TREE_CHAIN (parm);
13567           if (TREE_CODE (parm) == PARM_DECL)
13568             {
13569               tree type = TREE_TYPE (parm);
13570
13571               if (doing_semantic_analysis_p ())
13572                 {
13573                   tree cleanup;
13574
13575                   if (DECL_NAME (parm) == NULL_TREE
13576                       || TREE_CODE (parm) != VOID_TYPE)
13577                     pushdecl (parm);
13578                   else
13579                     cp_error ("parameter `%D' declared void", parm);
13580
13581                   cleanup = (processing_template_decl
13582                              ? NULL_TREE
13583                              : maybe_build_cleanup (parm));
13584
13585                   if (cleanup)
13586                     cleanups = tree_cons (parm, cleanup, cleanups);
13587                 }
13588               else if (type != error_mark_node
13589                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13590                 parms_have_cleanups = 1;
13591             }
13592           else
13593             {
13594               /* If we find an enum constant or a type tag,
13595                  put it aside for the moment.  */
13596               TREE_CHAIN (parm) = NULL_TREE;
13597               nonparms = chainon (nonparms, parm);
13598             }
13599         }
13600
13601       if (doing_semantic_analysis_p ())
13602         {
13603           /* Get the decls in their original chain order
13604              and record in the function.  This is all and only the
13605              PARM_DECLs that were pushed into scope by the loop above.  */
13606           DECL_ARGUMENTS (fndecl) = getdecls ();
13607           storetags (chainon (parmtags, gettags ()));
13608         }
13609     }
13610   else
13611     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13612
13613   /* Now store the final chain of decls for the arguments
13614      as the decl-chain of the current lexical scope.
13615      Put the enumerators in as well, at the front so that
13616      DECL_ARGUMENTS is not modified.  */
13617   if (doing_semantic_analysis_p ())
13618     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13619
13620   /* Initialize the RTL code for the function.  */
13621   DECL_SAVED_INSNS (fndecl) = 0;
13622   if (! building_stmt_tree ())
13623     expand_function_start (fndecl, parms_have_cleanups);
13624
13625   current_function_parms_stored = 1;
13626
13627   /* If this function is `main', emit a call to `__main'
13628      to run global initializers, etc.  */
13629   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13630     expand_main_function ();
13631
13632   /* Now that we have initialized the parms, we can start their
13633      cleanups.  We cannot do this before, since expand_decl_cleanup
13634      should not be called before the parm can be used.  */
13635   while (cleanups)
13636     {
13637       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13638                            TREE_VALUE (cleanups));
13639       cleanups = TREE_CHAIN (cleanups);
13640     }
13641
13642   /* Create a binding contour which can be used to catch
13643      cleanup-generated temporaries.  Also, if the return value needs or
13644      has initialization, deal with that now.  */
13645   if (parms_have_cleanups)
13646     {
13647       pushlevel (0);
13648       if (!building_stmt_tree ())
13649         expand_start_bindings (2);
13650     }
13651
13652   /* Do the starting of the exception specifications, if we have any.  */
13653   if (flag_exceptions && !processing_template_decl
13654       && flag_enforce_eh_specs
13655       && building_stmt_tree ()
13656       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13657     current_eh_spec_try_block = expand_start_eh_spec ();
13658 }
13659
13660 /* Bind a name and initialization to the return value of
13661    the current function.  */
13662
13663 void
13664 store_return_init (decl)
13665      tree decl;
13666 {
13667   /* If this named return value comes in a register, put it in a
13668      pseudo-register.  */
13669   if (DECL_REGISTER (decl))
13670     {
13671       original_result_rtx = DECL_RTL (decl);
13672       /* Note that the mode of the old DECL_RTL may be wider than the
13673          mode of DECL_RESULT, depending on the calling conventions for
13674          the processor.  For example, on the Alpha, a 32-bit integer
13675          is returned in a DImode register -- the DECL_RESULT has
13676          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
13677          here, we use the mode the back-end has already assigned for
13678          the return value.  */
13679       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13680     }
13681 }
13682
13683 \f
13684 /* We have finished doing semantic analysis on DECL, but have not yet
13685    generated RTL for its body.  Save away our current state, so that
13686    when we want to generate RTL later we know what to do.  */
13687
13688 static void
13689 save_function_data (decl)
13690      tree decl;
13691 {
13692   struct language_function *f;
13693
13694   /* Save the language-specific per-function data so that we can
13695      get it back when we really expand this function.  */
13696   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13697                       19990908);
13698
13699   /* Make a copy.  */
13700   f = ((struct language_function *)
13701        xmalloc (sizeof (struct language_function)));
13702   bcopy ((char *) cp_function_chain, (char *) f,
13703          sizeof (struct language_function));
13704   DECL_SAVED_FUNCTION_DATA (decl) = f;
13705
13706   /* Clear out the bits we don't need.  */
13707   f->x_base_init_list = NULL_TREE;
13708   f->x_member_init_list = NULL_TREE;
13709   f->x_stmt_tree.x_last_stmt = NULL_TREE;
13710   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
13711   f->x_result_rtx = NULL_RTX;
13712   f->x_named_label_uses = NULL;
13713   f->bindings = NULL;
13714
13715   /* When we get back here again, we will be expanding.  */
13716   f->x_expanding_p = 1;
13717
13718   /* If we've already decided that we cannot inline this function, we
13719      must remember that fact when we actually go to expand the
13720      function.  */
13721   f->cannot_inline = current_function_cannot_inline;
13722 }
13723
13724 /* At the end of every constructor we generate to code to return
13725    `this'.  Do that now.  */
13726
13727 static void
13728 finish_constructor_body ()
13729 {
13730   /* Any return from a constructor will end up here.  */
13731   add_tree (build_min_nt (LABEL_STMT, ctor_label));
13732
13733   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13734      generate the return, rather than a goto to CTOR_LABEL.  */
13735   ctor_label = NULL_TREE;
13736   /* In check_return_expr we translate an empty return from a
13737      constructor to a return of `this'.  */
13738   finish_return_stmt (NULL_TREE);
13739   /* Mark the end of the constructor.  */
13740   add_tree (build_min_nt (CTOR_STMT));
13741 }
13742
13743 /* At the end of every destructor we generate code to restore virtual
13744    function tables to the values desired by base classes and to call
13745    to base class destructors.  Do that now.  */
13746
13747 static void
13748 finish_destructor_body ()
13749 {
13750   tree compound_stmt;
13751   tree in_charge;
13752   tree virtual_size;
13753   tree exprstmt;
13754
13755   /* Create a block to contain all the extra code.  */
13756   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13757
13758   /* Any return from a destructor will end up here.  */
13759   add_tree (build_min_nt (LABEL_STMT, dtor_label));
13760
13761   /* Generate the code to call destructor on base class.  If this
13762      destructor belongs to a class with virtual functions, then set
13763      the virtual function table pointer to represent the type of our
13764      base class.  */
13765
13766   /* This side-effect makes call to `build_delete' generate the code
13767      we have to have at the end of this destructor.  `build_delete'
13768      will set the flag again.  */
13769   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13770
13771   /* These are two cases where we cannot delegate deletion.  */
13772   if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
13773       || TYPE_GETS_REG_DELETE (current_class_type))
13774     in_charge = integer_zero_node;
13775   else
13776     in_charge = current_in_charge_parm;
13777
13778   exprstmt = build_delete (current_class_type,
13779                            current_class_ref,
13780                            in_charge,
13781                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13782                            0);
13783
13784   if (exprstmt != error_mark_node
13785       && (TREE_CODE (exprstmt) != NOP_EXPR
13786           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13787           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13788     {
13789       if (exprstmt != void_zero_node)
13790         /* Don't call `expand_expr_stmt' if we're not going to do
13791            anything, since -Wall will give a diagnostic.  */
13792         finish_expr_stmt (exprstmt);
13793
13794       /* Run destructors for all virtual baseclasses.  */
13795       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13796         {
13797           tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
13798           tree if_stmt = begin_if_stmt ();
13799           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13800                                       current_in_charge_parm,
13801                                       integer_two_node),
13802                                if_stmt);
13803
13804           while (vbases)
13805             {
13806               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbases)))
13807                 {
13808                   tree vb = get_vbase
13809                     (BINFO_TYPE (vbases),
13810                      TYPE_BINFO (current_class_type));
13811                   finish_expr_stmt
13812                     (build_scoped_method_call
13813                      (current_class_ref, vb, dtor_identifier,
13814                       build_tree_list (NULL_TREE, integer_zero_node)));
13815                 }
13816               vbases = TREE_CHAIN (vbases);
13817             }
13818
13819           finish_then_clause (if_stmt);
13820           finish_if_stmt ();
13821         }
13822     }
13823
13824   virtual_size = c_sizeof (current_class_type);
13825
13826   /* At the end, call delete if that's what's requested.  */
13827
13828   /* FDIS sez: At the point of definition of a virtual destructor
13829      (including an implicit definition), non-placement operator delete
13830      shall be looked up in the scope of the destructor's class and if
13831      found shall be accessible and unambiguous.
13832
13833      This is somewhat unclear, but I take it to mean that if the class
13834      only defines placement deletes we don't do anything here.  So we
13835      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13836      they ever try to delete one of these.  */
13837   if (TYPE_GETS_REG_DELETE (current_class_type)
13838       || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13839     {
13840       tree if_stmt;
13841
13842       exprstmt = build_op_delete_call
13843         (DELETE_EXPR, current_class_ptr, virtual_size,
13844          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13845
13846       if_stmt = begin_if_stmt ();
13847       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13848                                   current_in_charge_parm,
13849                                   integer_one_node),
13850                            if_stmt);
13851       finish_expr_stmt (exprstmt);
13852       finish_then_clause (if_stmt);
13853       finish_if_stmt ();
13854     }
13855
13856   /* Close the block we started above.  */
13857   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13858 }
13859
13860 /* Finish up a function declaration and compile that function
13861    all the way to assembler language output.  The free the storage
13862    for the function definition.
13863
13864    This is called after parsing the body of the function definition.
13865    LINENO is the current line number.
13866
13867    FLAGS is a bitwise or of the following values:
13868      1 - CALL_POPLEVEL
13869        An extra call to poplevel (and expand_end_bindings) must be
13870        made to take care of the binding contour for the base
13871        initializers.  This is only relevant for constructors.
13872      2 - INCLASS_INLINE
13873        We just finished processing the body of an in-class inline
13874        function definition.  (This processing will have taken place
13875        after the class definition is complete.)  */
13876
13877 tree
13878 finish_function (lineno, flags)
13879      int lineno;
13880      int flags;
13881 {
13882   register tree fndecl = current_function_decl;
13883   tree fntype, ctype = NULL_TREE;
13884   /* Label to use if this function is supposed to return a value.  */
13885   tree no_return_label = NULL_TREE;
13886   int call_poplevel = (flags & 1) != 0;
13887   int inclass_inline = (flags & 2) != 0;
13888   int expand_p;
13889   int nested;
13890
13891   /* When we get some parse errors, we can end up without a
13892      current_function_decl, so cope.  */
13893   if (fndecl == NULL_TREE)
13894     return error_mark_node;
13895
13896   nested = function_depth > 1;
13897   fntype = TREE_TYPE (fndecl);
13898
13899   /*  TREE_READONLY (fndecl) = 1;
13900       This caused &foo to be of type ptr-to-const-function
13901       which then got a warning when stored in a ptr-to-function variable.  */
13902
13903   /* This happens on strange parse errors.  */
13904   if (! current_function_parms_stored)
13905     {
13906       call_poplevel = 0;
13907       store_parm_decls ();
13908     }
13909
13910   if (building_stmt_tree ())
13911     {
13912       if (DECL_CONSTRUCTOR_P (fndecl))
13913         {
13914           finish_constructor_body ();
13915           if (call_poplevel)
13916             do_poplevel ();
13917         }
13918       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13919         finish_destructor_body ();
13920       else if (DECL_MAIN_P (fndecl))
13921         {
13922           /* Make it so that `main' always returns 0 by default.  */
13923 #ifdef VMS
13924           finish_return_stmt (integer_one_node);
13925 #else
13926           finish_return_stmt (integer_zero_node);
13927 #endif
13928         }
13929
13930       /* Finish dealing with exception specifiers.  */
13931       if (flag_exceptions && !processing_template_decl
13932           && flag_enforce_eh_specs
13933           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13934         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13935                             (TREE_TYPE (current_function_decl)),
13936                             current_eh_spec_try_block);
13937     }
13938   else
13939     {
13940 #if 0
13941       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13942         {
13943           /* Keep this code around in case we later want to control debug info
13944              based on whether a type is "used".  (jason 1999-11-11) */
13945
13946           tree ttype = target_type (fntype);
13947           tree parmdecl;
13948
13949           if (IS_AGGR_TYPE (ttype))
13950             /* Let debugger know it should output info for this type.  */
13951             note_debug_info_needed (ttype);
13952
13953           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
13954             {
13955               ttype = target_type (TREE_TYPE (parmdecl));
13956               if (IS_AGGR_TYPE (ttype))
13957                 /* Let debugger know it should output info for this type.  */
13958                 note_debug_info_needed (ttype);
13959             }
13960         }
13961 #endif
13962
13963       /* Clean house because we will need to reorder insns here.  */
13964       do_pending_stack_adjust ();
13965
13966       if (dtor_label)
13967         ;
13968       else if (DECL_CONSTRUCTOR_P (fndecl))
13969         {
13970           if (call_poplevel)
13971             do_poplevel ();
13972         }
13973       else if (return_label != NULL_RTX
13974                && flag_this_is_variable <= 0
13975                && current_function_return_value == NULL_TREE
13976                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
13977         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13978
13979       if (flag_exceptions)
13980         expand_exception_blocks ();
13981
13982       /* If this function is supposed to return a value, ensure that
13983          we do not fall into the cleanups by mistake.  The end of our
13984          function will look like this:
13985
13986          user code (may have return stmt somewhere)
13987          goto no_return_label
13988          cleanup_label:
13989          cleanups
13990          goto return_label
13991          no_return_label:
13992          NOTE_INSN_FUNCTION_END
13993          return_label:
13994          things for return
13995
13996          If the user omits a return stmt in the USER CODE section, we
13997          will have a control path which reaches NOTE_INSN_FUNCTION_END.
13998          Otherwise, we won't.  */
13999       if (no_return_label)
14000         {
14001           DECL_CONTEXT (no_return_label) = fndecl;
14002           DECL_INITIAL (no_return_label) = error_mark_node;
14003           DECL_SOURCE_FILE (no_return_label) = input_filename;
14004           DECL_SOURCE_LINE (no_return_label) = lineno;
14005           expand_goto (no_return_label);
14006         }
14007
14008       if (cleanup_label)
14009         {
14010           /* Remove the binding contour which is used
14011              to catch cleanup-generated temporaries.  */
14012           expand_end_bindings (0, 0, 0);
14013           poplevel (0, 0, 0);
14014
14015           /* Emit label at beginning of cleanup code for parameters.  */
14016           emit_label (cleanup_label);
14017         }
14018
14019       /* Get return value into register if that's where it's supposed
14020          to be.  */
14021       if (original_result_rtx)
14022         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14023
14024       /* Finish building code that will trigger warnings if users forget
14025          to make their functions return values.  */
14026       if (no_return_label || cleanup_label)
14027         emit_jump (return_label);
14028       if (no_return_label)
14029         {
14030           /* We don't need to call `expand_*_return' here because we
14031              don't need any cleanups here--this path of code is only
14032              for error checking purposes.  */
14033           expand_label (no_return_label);
14034         }
14035
14036       /* We hard-wired immediate_size_expand to zero in
14037          start_function.  Expand_function_end will decrement this
14038          variable.  So, we set the variable to one here, so that after
14039          the decrement it will remain zero.  */
14040       immediate_size_expand = 1;
14041
14042       /* Generate rtl for function exit.  */
14043       expand_function_end (input_filename, lineno, 1);
14044     }
14045
14046   /* We have to save this value here in case
14047      maybe_end_member_template_processing decides to pop all the
14048      template parameters.  */
14049   expand_p = !building_stmt_tree ();
14050
14051   /* If we're saving up tree structure, tie off the function now.  */
14052   if (!expand_p)
14053     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14054
14055   /* This must come after expand_function_end because cleanups might
14056      have declarations (from inline functions) that need to go into
14057      this function's blocks.  */
14058   if (doing_semantic_analysis_p ())
14059     {
14060       if (current_binding_level->parm_flag != 1)
14061         my_friendly_abort (122);
14062       poplevel (1, 0, 1);
14063     }
14064
14065   /* Remember that we were in class scope.  */
14066   if (current_class_name)
14067     ctype = current_class_type;
14068
14069   /* Must mark the RESULT_DECL as being in this function.  */
14070   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14071
14072   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14073      to the FUNCTION_DECL node itself.  */
14074   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14075
14076   /* Save away current state, if appropriate.  */
14077   if (!expanding_p && !processing_template_decl)
14078     save_function_data (fndecl);
14079
14080   /* If this function calls `setjmp' it cannot be inlined.  When
14081      `longjmp' is called it is not guaranteed to restore the value of
14082      local variables that have been modified since the call to
14083      `setjmp'.  So, if were to inline this function into some caller
14084      `c', then when we `longjmp', we might not restore all variables
14085      in `c'.  (It might seem, at first blush, that there's no way for
14086      this function to modify local variables in `c', but their
14087      addresses may have been stored somewhere accessible to this
14088      function.)  */
14089   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14090     DECL_UNINLINABLE (fndecl) = 1;
14091
14092   if (expand_p)
14093     {
14094       int returns_null;
14095       int returns_value;
14096
14097       /* So we can tell if jump_optimize sets it to 1.  */
14098       can_reach_end = 0;
14099
14100       /* Before we call rest_of_compilation (which will pop the
14101          CURRENT_FUNCTION), we must save these values.  */
14102       returns_null = current_function_returns_null;
14103       returns_value = current_function_returns_value;
14104
14105       /* If this is a nested function (like a template instantiation
14106          that we're compiling in the midst of compiling something
14107          else), push a new GC context.  That will keep local variables
14108          on the stack from being collected while we're doing the
14109          compilation of this function.  */
14110       if (function_depth > 1)
14111         ggc_push_context ();
14112
14113       /* Run the optimizers and output the assembler code for this
14114          function.  */
14115       if (DECL_ARTIFICIAL (fndecl))
14116         {
14117           /* Do we really *want* to inline this synthesized method?  */
14118
14119           int save_fif = flag_inline_functions;
14120           flag_inline_functions = 1;
14121
14122           /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
14123              will check our size.  */
14124           DECL_INLINE (fndecl) = 0;
14125
14126           rest_of_compilation (fndecl);
14127           flag_inline_functions = save_fif;
14128         }
14129       else
14130         rest_of_compilation (fndecl);
14131
14132       /* Undo the call to ggc_push_context above.  */
14133       if (function_depth > 1)
14134         ggc_pop_context ();
14135
14136       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14137         {
14138           /* Set DECL_EXTERNAL so that assemble_external will be called as
14139              necessary.  We'll clear it again in finish_file.  */
14140           if (! DECL_EXTERNAL (fndecl))
14141             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14142           DECL_EXTERNAL (fndecl) = 1;
14143           mark_inline_for_output (fndecl);
14144         }
14145
14146 #if 0
14147       /* Keep this code around in case we later want to control debug info
14148          based on whether a type is "used".  (jason 1999-11-11) */
14149
14150       if (ctype && TREE_ASM_WRITTEN (fndecl))
14151         note_debug_info_needed (ctype);
14152 #endif
14153
14154       returns_null |= can_reach_end;
14155
14156       /* Since we don't normally go through c_expand_return for constructors,
14157          this normally gets the wrong value.
14158          Also, named return values have their return codes emitted after
14159          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
14160       if (DECL_CONSTRUCTOR_P (fndecl)
14161           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
14162         returns_null = 0;
14163
14164       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14165         cp_warning ("`noreturn' function `%D' does return", fndecl);
14166       else if ((warn_return_type || pedantic)
14167                && returns_null
14168                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14169         {
14170           /* If this function returns non-void and control can drop through,
14171              complain.  */
14172           cp_warning ("control reaches end of non-void function `%D'", fndecl);
14173         }
14174       /* With just -W, complain only if function returns both with
14175          and without a value.  */
14176       else if (extra_warnings && returns_value && returns_null)
14177         warning ("this function may return with or without a value");
14178     }
14179   else
14180     {
14181       /* Clear out memory we no longer need.  */
14182       free_after_parsing (cfun);
14183       /* Since we never call rest_of_compilation, we never clear
14184          CFUN.  Do so explicitly.  */
14185       free_after_compilation (cfun);
14186       cfun = NULL;
14187     }
14188
14189   /* If this is a in-class inline definition, we may have to pop the
14190      bindings for the template parameters that we added in
14191      maybe_begin_member_template_processing when start_function was
14192      called.  */
14193   if (inclass_inline)
14194     maybe_end_member_template_processing ();
14195
14196   /* Leave the scope of the class.  */
14197   if (ctype)
14198     pop_nested_class ();
14199
14200   --function_depth;
14201
14202   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14203       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14204     {
14205       tree t;
14206
14207       /* Stop pointing to the local nodes about to be freed.  */
14208       /* But DECL_INITIAL must remain nonzero so we know this
14209          was an actual function definition.  */
14210       DECL_INITIAL (fndecl) = error_mark_node;
14211       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14212         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14213     }
14214
14215   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14216     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14217   if (DECL_STATIC_DESTRUCTOR (fndecl))
14218     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14219
14220   /* Clean up.  */
14221   if (! nested)
14222     {
14223       /* Let the error reporting routines know that we're outside a
14224          function.  For a nested function, this value is used in
14225          pop_cp_function_context and then reset via pop_function_context.  */
14226       current_function_decl = NULL_TREE;
14227       /* We don't really care about obstacks, but the middle-end
14228          sometimes cares on what obstck things are located.  */
14229       permanent_allocation (1);
14230     }
14231
14232   return fndecl;
14233 }
14234 \f
14235 /* Create the FUNCTION_DECL for a function definition.
14236    DECLSPECS and DECLARATOR are the parts of the declaration;
14237    they describe the return type and the name of the function,
14238    but twisted together in a fashion that parallels the syntax of C.
14239
14240    This function creates a binding context for the function body
14241    as well as setting up the FUNCTION_DECL in current_function_decl.
14242
14243    Returns a FUNCTION_DECL on success.
14244
14245    If the DECLARATOR is not suitable for a function (it defines a datum
14246    instead), we return 0, which tells yyparse to report a parse error.
14247
14248    May return void_type_node indicating that this method is actually
14249    a friend.  See grokfield for more details.
14250
14251    Came here with a `.pushlevel' .
14252
14253    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14254    CHANGES TO CODE IN `grokfield'.  */
14255
14256 tree
14257 start_method (declspecs, declarator, attrlist)
14258      tree declarator, declspecs, attrlist;
14259 {
14260   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14261                                 attrlist);
14262
14263   /* Something too ugly to handle.  */
14264   if (fndecl == NULL_TREE)
14265     return NULL_TREE;
14266
14267   /* Pass friends other than inline friend functions back.  */
14268   if (fndecl == void_type_node)
14269     return fndecl;
14270
14271   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14272     /* Not a function, tell parser to report parse error.  */
14273     return NULL_TREE;
14274
14275   if (DECL_IN_AGGR_P (fndecl))
14276     {
14277       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14278         {
14279           if (DECL_CONTEXT (fndecl)
14280               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14281             cp_error ("`%D' is already defined in class %s", fndecl,
14282                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14283         }
14284       return void_type_node;
14285     }
14286
14287   check_template_shadow (fndecl);
14288
14289   DECL_THIS_INLINE (fndecl) = 1;
14290
14291   if (flag_default_inline)
14292     DECL_INLINE (fndecl) = 1;
14293
14294   /* We process method specializations in finish_struct_1.  */
14295   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14296     fndecl = push_template_decl (fndecl);
14297
14298   /* We read in the parameters on the maybepermanent_obstack,
14299      but we won't be getting back to them until after we
14300      may have clobbered them.  So the call to preserve_data
14301      will keep them safe.  */
14302   preserve_data ();
14303
14304   if (! DECL_FRIEND_P (fndecl))
14305     {
14306       if (TREE_CHAIN (fndecl))
14307         {
14308           fndecl = copy_node (fndecl);
14309           TREE_CHAIN (fndecl) = NULL_TREE;
14310         }
14311
14312       if (DECL_CONSTRUCTOR_P (fndecl))
14313         {
14314           if (! grok_ctor_properties (current_class_type, fndecl))
14315             return void_type_node;
14316         }
14317       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14318         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14319     }
14320
14321   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14322
14323   /* Make a place for the parms */
14324   pushlevel (0);
14325   current_binding_level->parm_flag = 1;
14326
14327   DECL_IN_AGGR_P (fndecl) = 1;
14328   return fndecl;
14329 }
14330
14331 /* Go through the motions of finishing a function definition.
14332    We don't compile this method until after the whole class has
14333    been processed.
14334
14335    FINISH_METHOD must return something that looks as though it
14336    came from GROKFIELD (since we are defining a method, after all).
14337
14338    This is called after parsing the body of the function definition.
14339    STMTS is the chain of statements that makes up the function body.
14340
14341    DECL is the ..._DECL that `start_method' provided.  */
14342
14343 tree
14344 finish_method (decl)
14345      tree decl;
14346 {
14347   register tree fndecl = decl;
14348   tree old_initial;
14349
14350   register tree link;
14351
14352   if (decl == void_type_node)
14353     return decl;
14354
14355   old_initial = DECL_INITIAL (fndecl);
14356
14357   /* Undo the level for the parms (from start_method).
14358      This is like poplevel, but it causes nothing to be
14359      saved.  Saving information here confuses symbol-table
14360      output routines.  Besides, this information will
14361      be correctly output when this method is actually
14362      compiled.  */
14363
14364   /* Clear out the meanings of the local variables of this level;
14365      also record in each decl which block it belongs to.  */
14366
14367   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14368     {
14369       if (DECL_NAME (link) != NULL_TREE)
14370         pop_binding (DECL_NAME (link), link);
14371       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14372       DECL_CONTEXT (link) = NULL_TREE;
14373     }
14374
14375   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14376                       (HOST_WIDE_INT) current_binding_level->level_chain,
14377                       current_binding_level->parm_flag,
14378                       current_binding_level->keep);
14379
14380   poplevel (0, 0, 0);
14381
14382   DECL_INITIAL (fndecl) = old_initial;
14383
14384   /* We used to check if the context of FNDECL was different from
14385      current_class_type as another way to get inside here.  This didn't work
14386      for String.cc in libg++.  */
14387   if (DECL_FRIEND_P (fndecl))
14388     {
14389       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14390         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14391       decl = void_type_node;
14392     }
14393
14394   return decl;
14395 }
14396 \f
14397 /* Called when a new struct TYPE is defined.
14398    If this structure or union completes the type of any previous
14399    variable declaration, lay it out and output its rtl.  */
14400
14401 void
14402 hack_incomplete_structures (type)
14403      tree type;
14404 {
14405   tree *list;
14406   struct binding_level *level;
14407
14408   if (!type) /* Don't do this for class templates.  */
14409     return;
14410
14411   if (namespace_bindings_p ())
14412     {
14413       level = 0;
14414       list = &namespace_scope_incomplete;
14415     }
14416   else
14417     {
14418       level = innermost_nonclass_level ();
14419       list = &level->incomplete;
14420     }
14421
14422   while (1)
14423     {
14424       while (*list)
14425         {
14426           tree decl = TREE_VALUE (*list);
14427           if ((decl && TREE_TYPE (decl) == type)
14428               || (TREE_TYPE (decl)
14429                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14430                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14431             {
14432               int toplevel = toplevel_bindings_p ();
14433               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14434                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14435                 layout_type (TREE_TYPE (decl));
14436               layout_decl (decl, 0);
14437               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14438               if (! toplevel)
14439                 {
14440                   tree cleanup;
14441                   expand_decl (decl);
14442                   cleanup = maybe_build_cleanup (decl);
14443                   expand_decl_init (decl);
14444                   if (! expand_decl_cleanup (decl, cleanup))
14445                     cp_error ("parser lost in parsing declaration of `%D'",
14446                               decl);
14447                 }
14448               *list = TREE_CHAIN (*list);
14449             }
14450           else
14451             list = &TREE_CHAIN (*list);
14452         }
14453
14454       /* Keep looking through artificial binding levels generated
14455          for local variables.  */
14456       if (level && level->keep == 2)
14457         {
14458           level = level->level_chain;
14459           list = &level->incomplete;
14460         }
14461       else
14462         break;
14463     }
14464 }
14465
14466 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14467    See build_delete for information about AUTO_DELETE.
14468
14469    Don't build these on the momentary obstack; they must live
14470    the life of the binding contour.  */
14471
14472 static tree
14473 maybe_build_cleanup_1 (decl, auto_delete)
14474      tree decl, auto_delete;
14475 {
14476   tree type = TREE_TYPE (decl);
14477   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14478     {
14479       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14480       tree rval;
14481
14482       if (TREE_CODE (type) == ARRAY_TYPE)
14483         rval = decl;
14484       else
14485         {
14486           mark_addressable (decl);
14487           rval = build_unary_op (ADDR_EXPR, decl, 0);
14488         }
14489
14490       /* Optimize for space over speed here.  */
14491       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14492           || flag_expensive_optimizations)
14493         flags |= LOOKUP_NONVIRTUAL;
14494
14495       rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
14496
14497       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14498           && ! TYPE_HAS_DESTRUCTOR (type))
14499         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14500                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14501
14502       return rval;
14503     }
14504   return 0;
14505 }
14506
14507 /* If DECL is of a type which needs a cleanup, build that cleanup
14508    here.  The cleanup does free the storage with a call to delete.  */
14509
14510 tree
14511 maybe_build_cleanup_and_delete (decl)
14512      tree decl;
14513 {
14514   return maybe_build_cleanup_1 (decl, integer_three_node);
14515 }
14516
14517 /* If DECL is of a type which needs a cleanup, build that cleanup
14518    here.  The cleanup does not free the storage with a call a delete.  */
14519
14520 tree
14521 maybe_build_cleanup (decl)
14522      tree decl;
14523 {
14524   return maybe_build_cleanup_1 (decl, integer_two_node);
14525 }
14526 \f
14527 /* Expand a C++ expression at the statement level.
14528    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14529    The C++ type checker should get all of these out when
14530    expressions are combined with other, type-providing, expressions,
14531    leaving only orphan expressions, such as:
14532
14533    &class::bar;         / / takes its address, but does nothing with it.  */
14534
14535 void
14536 cplus_expand_expr_stmt (exp)
14537      tree exp;
14538 {
14539   if (stmts_are_full_exprs_p)
14540     exp = convert_to_void (exp, "statement");
14541
14542 #if 0
14543   /* We should do this eventually, but right now this causes regex.o from
14544      libg++ to miscompile, and tString to core dump.  */
14545   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14546 #endif
14547
14548   /* If we don't do this, we end up down inside expand_expr
14549      trying to do TYPE_MODE on the ERROR_MARK, and really
14550      go outside the bounds of the type.  */
14551   if (exp != error_mark_node)
14552     expand_expr_stmt (exp);
14553 }
14554
14555 /* When a stmt has been parsed, this function is called.  */
14556
14557 void
14558 finish_stmt ()
14559 {
14560   /* Always assume this statement was not an expression statement.  If
14561      it actually was an expression statement, its our callers
14562      responsibility to fix this up.  */
14563   last_expr_type = NULL_TREE;
14564 }
14565
14566 /* DECL was originally constructed as a non-static member function,
14567    but turned out to be static.  Update it accordingly.  */
14568
14569 void
14570 revert_static_member_fn (decl)
14571      tree decl;
14572 {
14573   tree tmp;
14574   tree function = TREE_TYPE (decl);
14575   tree args = TYPE_ARG_TYPES (function);
14576
14577   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14578       != TYPE_UNQUALIFIED)
14579     cp_error ("static member function `%#D' declared with type qualifiers",
14580               *decl);
14581
14582   args = TREE_CHAIN (args);
14583   tmp = build_function_type (TREE_TYPE (function), args);
14584   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14585   tmp = build_exception_variant (tmp,
14586                                  TYPE_RAISES_EXCEPTIONS (function));
14587   TREE_TYPE (decl) = tmp;
14588   if (DECL_ARGUMENTS (decl))
14589     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14590   DECL_STATIC_FUNCTION_P (decl) = 1;
14591 }
14592
14593 /* Initialize the variables used during compilation of a C++
14594    function.  */
14595
14596 static void
14597 push_cp_function_context (f)
14598      struct function *f;
14599 {
14600   struct language_function *p
14601     = ((struct language_function *)
14602        xcalloc (1, sizeof (struct language_function)));
14603   f->language = p;
14604
14605   /* It takes an explicit call to expand_body to generate RTL for a
14606      function.  */
14607   expanding_p = 0;
14608
14609   /* Whenever we start a new function, we destroy temporaries in the
14610      usual way.  */
14611   stmts_are_full_exprs_p = 1;
14612 }
14613
14614 /* Free the language-specific parts of F, now that we've finished
14615    compiling the function.  */
14616
14617 static void
14618 pop_cp_function_context (f)
14619      struct function *f;
14620 {
14621   if (f->language)
14622     free (f->language);
14623   f->language = 0;
14624 }
14625
14626 /* Mark P for GC.  */
14627
14628 static void
14629 mark_lang_function (p)
14630      struct language_function *p;
14631 {
14632   if (!p)
14633     return;
14634
14635   ggc_mark_tree (p->x_named_labels);
14636   ggc_mark_tree (p->x_ctor_label);
14637   ggc_mark_tree (p->x_dtor_label);
14638   ggc_mark_tree (p->x_base_init_list);
14639   ggc_mark_tree (p->x_member_init_list);
14640   ggc_mark_tree (p->x_current_class_ptr);
14641   ggc_mark_tree (p->x_current_class_ref);
14642   ggc_mark_tree (p->x_eh_spec_try_block);
14643   ggc_mark_tree (p->x_scope_stmt_stack);
14644
14645   ggc_mark_rtx (p->x_result_rtx);
14646
14647   mark_stmt_tree (&p->x_stmt_tree);
14648   mark_binding_level (&p->bindings);
14649 }
14650
14651 /* Mark the language-specific data in F for GC.  */
14652
14653 static void
14654 mark_cp_function_context (f)
14655      struct function *f;
14656 {
14657   mark_lang_function (f->language);
14658 }
14659
14660 int
14661 in_function_p ()
14662 {
14663   return function_depth != 0;
14664 }
14665
14666
14667 void
14668 lang_mark_false_label_stack (l)
14669      struct label_node *l;
14670 {
14671   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14672   my_friendly_assert (l == NULL, 19990904);
14673 }
14674
14675 void
14676 lang_mark_tree (t)
14677      tree t;
14678 {
14679   enum tree_code code = TREE_CODE (t);
14680   if (code == IDENTIFIER_NODE)
14681     {
14682       struct lang_identifier *li = (struct lang_identifier *) t;
14683       struct lang_id2 *li2 = li->x;
14684       ggc_mark_tree (li->namespace_bindings);
14685       ggc_mark_tree (li->bindings);
14686       ggc_mark_tree (li->class_value);
14687       ggc_mark_tree (li->class_template_info);
14688
14689       if (li2)
14690         {
14691           ggc_mark_tree (li2->label_value);
14692           ggc_mark_tree (li2->implicit_decl);
14693           ggc_mark_tree (li2->error_locus);
14694         }
14695     }
14696   else if (code == CPLUS_BINDING)
14697     {
14698       if (BINDING_HAS_LEVEL_P (t))
14699         mark_binding_level (&BINDING_LEVEL (t));
14700       else
14701         ggc_mark_tree (BINDING_SCOPE (t));
14702       ggc_mark_tree (BINDING_VALUE (t));
14703     }
14704   else if (code == OVERLOAD)
14705     ggc_mark_tree (OVL_FUNCTION (t));
14706   else if (code == TEMPLATE_PARM_INDEX)
14707     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14708   else if (TREE_CODE_CLASS (code) == 'd')
14709     {
14710       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14711
14712       if (ld)
14713         {
14714           ggc_mark (ld);
14715           if (!DECL_GLOBAL_CTOR_P (t) && !DECL_GLOBAL_DTOR_P (t))
14716             ggc_mark_tree (ld->decl_flags.u2.access);
14717           ggc_mark_tree (ld->decl_flags.context);
14718           if (TREE_CODE (t) != NAMESPACE_DECL)
14719             ggc_mark_tree (ld->decl_flags.u.template_info);
14720           else
14721             mark_binding_level (&NAMESPACE_LEVEL (t));
14722           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14723             {
14724               ggc_mark_tree (ld->main_decl_variant);
14725               ggc_mark_tree (ld->befriending_classes);
14726               ggc_mark_tree (ld->saved_tree);
14727               if (TREE_CODE (t) == TYPE_DECL)
14728                 ggc_mark_tree (ld->u.sorted_fields);
14729               else if (TREE_CODE (t) == FUNCTION_DECL
14730                        && !DECL_PENDING_INLINE_P (t))
14731                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14732             }
14733         }
14734     }
14735   else if (TREE_CODE_CLASS (code) == 't')
14736     {
14737       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14738
14739       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14740                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14741         {
14742           ggc_mark (lt);
14743           ggc_mark_tree (lt->vfields);
14744           ggc_mark_tree (lt->vbases);
14745           ggc_mark_tree (lt->tags);
14746           ggc_mark_tree (lt->search_slot);
14747           ggc_mark_tree (lt->size);
14748           ggc_mark_tree (lt->pure_virtuals);
14749           ggc_mark_tree (lt->friend_classes);
14750           ggc_mark_tree (lt->rtti);
14751           ggc_mark_tree (lt->methods);
14752           ggc_mark_tree (lt->template_info);
14753           ggc_mark_tree (lt->befriending_classes);
14754         }
14755       else if (lt)
14756         /* In the case of pointer-to-member function types, the
14757            TYPE_LANG_SPECIFIC is really just a tree.  */
14758         ggc_mark_tree ((tree) lt);
14759     }
14760 }