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 (TYPE_SIZE (current_class_type) == NULL_TREE)
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 (TYPE_SIZE (current_class_type) == NULL_TREE)
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           && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
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               && TYPE_SIZE (TREE_TYPE (newdecl))
4672               && TYPE_SIZE (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 && TYPE_SIZE (complete_type (context)) != NULL_TREE)
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 (TYPE_SIZE (complete_type (type)) != NULL_TREE)
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 (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
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           && TYPE_SIZE (complete_type (type)) == NULL_TREE)
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) && TYPE_SIZE (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 (TYPE_SIZE (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                && !TYPE_SIZE (TREE_TYPE (type)))
7490         {
7491           cp_error ("elements of array `%#D' have incomplete type", decl);
7492           init = NULL_TREE;
7493         }
7494       else if (!TYPE_SIZE (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 (TYPE_SIZE (type) != NULL_TREE
7569           && TYPE_NEEDS_CONSTRUCTING (type))
7570         init = obscure_complex_init (decl, NULL_TREE);
7571
7572     }
7573   else
7574     check_for_uninitialized_const_var (decl);
7575
7576   return init;
7577 }
7578
7579 /* If DECL is not a local variable, give it RTL.  */
7580
7581 static void
7582 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7583      tree decl;
7584      tree init;
7585      const char *asmspec;
7586 {
7587   int toplev;
7588   tree type;
7589
7590   type = TREE_TYPE (decl);
7591   toplev = toplevel_bindings_p ();
7592
7593   /* Handle non-variables up front.  */
7594   if (TREE_CODE (decl) != VAR_DECL)
7595     {
7596       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7597       return;
7598     }
7599
7600   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7601   if (asmspec)
7602     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7603
7604   if (DECL_VIRTUAL_P (decl))
7605     make_decl_rtl (decl, NULL_PTR, toplev);
7606   else if (TREE_READONLY (decl)
7607            && DECL_INITIAL (decl) != NULL_TREE
7608            && DECL_INITIAL (decl) != error_mark_node
7609            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7610     {
7611       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7612
7613       if (toplev && ! TREE_PUBLIC (decl))
7614         {
7615           /* If this is a static const, change its apparent linkage
7616              if it belongs to a #pragma interface.  */
7617           if (!interface_unknown)
7618             {
7619               TREE_PUBLIC (decl) = 1;
7620               DECL_EXTERNAL (decl) = interface_only;
7621             }
7622           make_decl_rtl (decl, asmspec, toplev);
7623         }
7624       else if (toplev)
7625         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7626     }
7627   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7628     {
7629       my_friendly_assert (TREE_STATIC (decl), 19990828);
7630
7631       if (init == NULL_TREE
7632 #ifdef DEFAULT_STATIC_DEFS
7633           /* If this code is dead, then users must
7634              explicitly declare static member variables
7635              outside the class def'n as well.  */
7636           && TYPE_NEEDS_CONSTRUCTING (type)
7637 #endif
7638           )
7639         {
7640           DECL_EXTERNAL (decl) = 1;
7641           make_decl_rtl (decl, asmspec, 1);
7642         }
7643       else
7644         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7645     }
7646   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7647            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7648     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7649 }
7650
7651 /* Create RTL for the local static variable DECL.  */
7652
7653 void
7654 make_rtl_for_local_static (decl)
7655      tree decl;
7656 {
7657   const char *asmspec = NULL;
7658
7659   /* If we inlined this variable, we could see it's declaration
7660      again.  */
7661   if (DECL_RTL (decl))
7662     return;
7663
7664   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7665     {
7666       /* The only way this situaton can occur is if the
7667          user specified a name for this DECL using the
7668          `attribute' syntax.  */
7669       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7670       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7671     }
7672
7673   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7674 }
7675
7676 /* The old ARM scoping rules injected variables declared in the
7677    initialization statement of a for-statement into the surrounding
7678    scope.  We support this usage, in order to be backward-compatible.
7679    DECL is a just-declared VAR_DECL; if necessary inject its
7680    declaration into the surrounding scope.  */
7681
7682 void
7683 maybe_inject_for_scope_var (decl)
7684      tree decl;
7685 {
7686   if (current_binding_level->is_for_scope)
7687     {
7688       struct binding_level *outer
7689         = current_binding_level->level_chain;
7690
7691       /* Check to see if the same name is already bound at the outer
7692          level, either because it was directly declared, or because a
7693          dead for-decl got preserved.  In either case, the code would
7694          not have been valid under the ARM scope rules, so clear
7695          is_for_scope for the current_binding_level.
7696
7697          Otherwise, we need to preserve the temp slot for decl to last
7698          into the outer binding level.  */
7699
7700       tree outer_binding
7701         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7702
7703       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7704           && (TREE_CODE (BINDING_VALUE (outer_binding))
7705               == VAR_DECL)
7706           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7707         {
7708           BINDING_VALUE (outer_binding)
7709             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7710           current_binding_level->is_for_scope = 0;
7711         }
7712       else if (DECL_IN_MEMORY_P (decl))
7713         preserve_temp_slots (DECL_RTL (decl));
7714     }
7715 }
7716
7717 /* Generate code to initialize DECL (a local variable).  */
7718
7719 void
7720 initialize_local_var (decl, init, flags)
7721      tree decl;
7722      tree init;
7723      int flags;
7724 {
7725   tree type = TREE_TYPE (decl);
7726
7727   /* If the type is bogus, don't bother initializing the variable.  */
7728   if (type == error_mark_node)
7729     return;
7730
7731   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7732     {
7733       /* If we used it already as memory, it must stay in memory.  */
7734       DECL_INITIAL (decl) = NULL_TREE;
7735       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7736     }
7737
7738   /* Local statics are handled differently from ordinary automatic
7739      variables.  */
7740   if (TREE_STATIC (decl))
7741     {
7742       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7743           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7744         expand_static_init (decl, init);
7745       return;
7746     }
7747
7748   if (DECL_SIZE (decl) && type != error_mark_node)
7749     {
7750       int already_used;
7751
7752       /* Compute and store the initial value.  */
7753       already_used = TREE_USED (decl) || TREE_USED (type);
7754
7755       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7756         {
7757           int saved_stmts_are_full_exprs_p;
7758
7759           emit_line_note (DECL_SOURCE_FILE (decl),
7760                           DECL_SOURCE_LINE (decl));
7761           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7762           stmts_are_full_exprs_p = 1;
7763           finish_expr_stmt (build_aggr_init (decl, init, flags));
7764           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7765         }
7766
7767       /* Set this to 0 so we can tell whether an aggregate which was
7768          initialized was ever used.  Don't do this if it has a
7769          destructor, so we don't complain about the 'resource
7770          allocation is initialization' idiom.  Now set
7771          attribute((unused)) on types so decls of that type will be
7772          marked used. (see TREE_USED, above.)  */
7773       if (TYPE_NEEDS_CONSTRUCTING (type)
7774           && ! already_used
7775           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7776           && DECL_NAME (decl))
7777         TREE_USED (decl) = 0;
7778       else if (already_used)
7779         TREE_USED (decl) = 1;
7780     }
7781 }
7782
7783 /* Generate code to destroy DECL (a local variable).  */
7784
7785 static void
7786 destroy_local_var (decl)
7787      tree decl;
7788 {
7789   tree type = TREE_TYPE (decl);
7790   tree cleanup;
7791
7792   /* Only variables get cleaned up.  */
7793   if (TREE_CODE (decl) != VAR_DECL)
7794     return;
7795
7796   /* And only things with destructors need cleaning up.  */
7797   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7798     return;
7799
7800   if (TREE_CODE (decl) == VAR_DECL &&
7801       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7802     /* We don't clean up things that aren't defined in this
7803        translation unit, or that need a static cleanup.  The latter
7804        are handled by finish_file.  */
7805     return;
7806
7807   /* Compute the cleanup.  */
7808   cleanup = maybe_build_cleanup (decl);
7809
7810   /* Record the cleanup required for this declaration.  */
7811   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7812       && cleanup)
7813     finish_decl_cleanup (decl, cleanup);
7814 }
7815
7816 /* Let the back-end know about DECL.  */
7817
7818 void
7819 emit_local_var (decl)
7820      tree decl;
7821 {
7822   /* Create RTL for this variable.  */
7823   if (DECL_RTL (decl))
7824     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7825        All other local variables are assigned RTL in this function.  */
7826     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
7827                         19990828);
7828   else
7829     {
7830       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7831         /* The user must have specified an assembler name for this
7832            variable.  Set that up now.  */
7833         rest_of_decl_compilation
7834           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
7835            /*top_level=*/0, /*at_end=*/0);
7836       else
7837         expand_decl (decl);
7838     }
7839
7840   /* Actually do the initialization.  */
7841   expand_start_target_temps ();
7842   expand_decl_init (decl);
7843   expand_end_target_temps ();
7844 }
7845
7846 /* Finish processing of a declaration;
7847    install its line number and initial value.
7848    If the length of an array type is not known before,
7849    it must be determined now, from the initial value, or it is an error.
7850
7851    INIT0 holds the value of an initializer that should be allowed to escape
7852    the normal rules.
7853
7854    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7855    if the (init) syntax was used.  */
7856
7857 void
7858 cp_finish_decl (decl, init, asmspec_tree, flags)
7859      tree decl, init;
7860      tree asmspec_tree;
7861      int flags;
7862 {
7863   register tree type;
7864   tree ttype = NULL_TREE;
7865   const char *asmspec = NULL;
7866   int was_readonly = 0;
7867
7868   if (! decl)
7869     {
7870       if (init)
7871         error ("assignment (not initialization) in declaration");
7872       return;
7873     }
7874
7875   /* If a name was specified, get the string.  */
7876   if (asmspec_tree)
7877       asmspec = TREE_STRING_POINTER (asmspec_tree);
7878
7879   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7880     {
7881       cp_error ("cannot initialize `%D' to namespace `%D'",
7882                 decl, init);
7883       init = NULL_TREE;
7884     }
7885
7886   if (current_class_type
7887       && CP_DECL_CONTEXT (decl) == current_class_type
7888       && TYPE_BEING_DEFINED (current_class_type)
7889       && (DECL_INITIAL (decl) || init))
7890     DECL_DEFINED_IN_CLASS_P (decl) = 1;
7891
7892   if (TREE_CODE (decl) == VAR_DECL
7893       && DECL_CONTEXT (decl)
7894       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7895       && DECL_CONTEXT (decl) != current_namespace
7896       && init)
7897     {
7898       /* Leave the namespace of the object. */
7899       pop_decl_namespace ();
7900     }
7901
7902   type = TREE_TYPE (decl);
7903
7904   if (type == error_mark_node)
7905     return;
7906
7907   /* Add this declaration to the statement-tree.  */
7908   if (building_stmt_tree () && at_function_scope_p ())
7909     add_decl_stmt (decl);
7910
7911   if (TYPE_HAS_MUTABLE_P (type))
7912     TREE_READONLY (decl) = 0;
7913
7914   if (processing_template_decl)
7915     {
7916       if (init && DECL_INITIAL (decl))
7917         DECL_INITIAL (decl) = init;
7918       goto finish_end0;
7919     }
7920
7921   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7922   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7923
7924   /* Take care of TYPE_DECLs up front.  */
7925   if (TREE_CODE (decl) == TYPE_DECL)
7926     {
7927       if (init && DECL_INITIAL (decl))
7928         {
7929           /* typedef foo = bar; store the type of bar as the type of foo.  */
7930           TREE_TYPE (decl) = type = TREE_TYPE (init);
7931           DECL_INITIAL (decl) = init = NULL_TREE;
7932         }
7933       if (type != error_mark_node
7934           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7935         {
7936           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7937             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7938           set_identifier_type_value (DECL_NAME (decl), type);
7939           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7940         }
7941       GNU_xref_decl (current_function_decl, decl);
7942
7943       /* If we have installed this as the canonical typedef for this
7944          type, and that type has not been defined yet, delay emitting
7945          the debug information for it, as we will emit it later.  */
7946       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7947           && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
7948         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7949
7950       rest_of_decl_compilation (decl, NULL_PTR,
7951                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7952       goto finish_end;
7953     }
7954
7955   if (TREE_CODE (decl) != FUNCTION_DECL)
7956     ttype = target_type (type);
7957
7958   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7959       && TYPE_NEEDS_CONSTRUCTING (type))
7960     {
7961       /* Currently, GNU C++ puts constants in text space, making them
7962          impossible to initialize.  In the future, one would hope for
7963          an operating system which understood the difference between
7964          initialization and the running of a program.  */
7965       was_readonly = 1;
7966       TREE_READONLY (decl) = 0;
7967     }
7968
7969   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
7970     {
7971       /* This must override the asm specifier which was placed by
7972          grokclassfn.  Lay this out fresh.  */
7973       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
7974       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7975       make_decl_rtl (decl, asmspec, 0);
7976     }
7977
7978   /* Deduce size of array from initialization, if not already known.  */
7979   maybe_deduce_size_from_array_init (decl, init);
7980   init = check_initializer (decl, init);
7981
7982   GNU_xref_decl (current_function_decl, decl);
7983
7984   if (TREE_CODE (decl) == VAR_DECL)
7985     layout_var_decl (decl);
7986
7987   /* Output the assembler code and/or RTL code for variables and functions,
7988      unless the type is an undefined structure or union.
7989      If not, it will get done when the type is completed.  */
7990   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
7991       || TREE_CODE (decl) == RESULT_DECL)
7992     {
7993       if (TREE_CODE (decl) == VAR_DECL)
7994         maybe_commonize_var (decl);
7995
7996       make_rtl_for_nonlocal_decl (decl, init, asmspec);
7997
7998       if (TREE_CODE (type) == FUNCTION_TYPE
7999           || TREE_CODE (type) == METHOD_TYPE)
8000         abstract_virtuals_error (decl,
8001                                  strip_array_types (TREE_TYPE (type)));
8002       else
8003         abstract_virtuals_error (decl, strip_array_types (type));
8004
8005       if (TREE_CODE (decl) == FUNCTION_DECL)
8006         ;
8007       else if (DECL_EXTERNAL (decl)
8008                && ! (DECL_LANG_SPECIFIC (decl)
8009                      && DECL_NOT_REALLY_EXTERN (decl)))
8010         {
8011           if (init)
8012             DECL_INITIAL (decl) = init;
8013         }
8014       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8015         {
8016           /* This is a local declaration.  */
8017           if (doing_semantic_analysis_p ())
8018             maybe_inject_for_scope_var (decl);
8019           /* Initialize the local variable.  But, if we're building a
8020              statement-tree, we'll do the initialization when we
8021              expand the tree.  */
8022           if (processing_template_decl)
8023             {
8024               if (init || DECL_INITIAL (decl) == error_mark_node)
8025                 DECL_INITIAL (decl) = init;
8026             }
8027           else
8028             {
8029               /* If we're not building RTL, then we need to do so
8030                  now.  */
8031               if (!building_stmt_tree ())
8032                 emit_local_var (decl);
8033               /* Initialize the variable.  */
8034               initialize_local_var (decl, init, flags);
8035               /* Clean up the variable.  */
8036               destroy_local_var (decl);
8037             }
8038         }
8039       else if (TREE_STATIC (decl) && type != error_mark_node)
8040         {
8041           /* Cleanups for static variables are handled by `finish_file'.  */
8042           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8043               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8044             expand_static_init (decl, init);
8045         }
8046     finish_end0:
8047
8048       /* Undo call to `pushclass' that was done in `start_decl'
8049          due to initialization of qualified member variable.
8050          I.e., Foo::x = 10;  */
8051       {
8052         tree context = CP_DECL_CONTEXT (decl);
8053         if (context
8054             && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
8055             && (TREE_CODE (decl) == VAR_DECL
8056                 /* We also have a pushclass done that we need to undo here
8057                    if we're at top level and declare a method.  */
8058                 || TREE_CODE (decl) == FUNCTION_DECL)
8059             /* If size hasn't been set, we're still defining it,
8060                and therefore inside the class body; don't pop
8061                the binding level..  */
8062             && TYPE_SIZE (context) != NULL_TREE
8063             && context == current_class_type)
8064           pop_nested_class ();
8065       }
8066     }
8067
8068  finish_end:
8069
8070   if (was_readonly)
8071     TREE_READONLY (decl) = 1;
8072 }
8073
8074 /* This is here for a midend callback from c-common.c */
8075
8076 void
8077 finish_decl (decl, init, asmspec_tree)
8078      tree decl, init;
8079      tree asmspec_tree;
8080 {
8081   cp_finish_decl (decl, init, asmspec_tree, 0);
8082 }
8083
8084 /* Returns a declaration for a VAR_DECL as if:
8085
8086      extern "C" TYPE NAME;
8087
8088    had been seen.  Used to create compiler-generated global
8089    variables.  */
8090
8091 tree
8092 declare_global_var (name, type)
8093      tree name;
8094      tree type;
8095 {
8096   tree decl;
8097
8098   push_to_top_level ();
8099   decl = build_decl (VAR_DECL, name, type);
8100   TREE_PUBLIC (decl) = 1;
8101   DECL_EXTERNAL (decl) = 1;
8102   DECL_ARTIFICIAL (decl) = 1;
8103   pushdecl (decl);
8104   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8105   pop_from_top_level ();
8106
8107   return decl;
8108 }
8109
8110 /* Returns a pointer to the `atexit' function.  Note that if
8111    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8112    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8113
8114 static tree
8115 get_atexit_node ()
8116 {
8117   tree atexit_fndecl;
8118   tree arg_types;
8119   tree fn_type;
8120   tree fn_ptr_type;
8121   const char *name;
8122
8123   if (atexit_node)
8124     return atexit_node;
8125
8126   if (flag_use_cxa_atexit)
8127     {
8128       /* The declaration for `__cxa_atexit' is:
8129
8130            int __cxa_atexit (void (*)(void *), void *, void *)
8131
8132          We build up the argument types and then then function type
8133          itself.  */
8134
8135       /* First, build the pointer-to-function type for the first
8136          argument.  */
8137       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8138       fn_type = build_function_type (void_type_node, arg_types);
8139       fn_ptr_type = build_pointer_type (fn_type);
8140       /* Then, build the rest of the argument types.  */
8141       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8142       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8143       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8144       /* And the final __cxa_atexit type.  */
8145       fn_type = build_function_type (integer_type_node, arg_types);
8146       fn_ptr_type = build_pointer_type (fn_type);
8147       name = "__cxa_atexit";
8148     }
8149   else
8150     {
8151       /* The declaration for `atexit' is:
8152
8153            int atexit (void (*)());
8154
8155          We build up the argument types and then then function type
8156          itself.  */
8157       fn_type = build_function_type (void_type_node, void_list_node);
8158       fn_ptr_type = build_pointer_type (fn_type);
8159       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8160       /* Build the final atexit type.  */
8161       fn_type = build_function_type (integer_type_node, arg_types);
8162       name = "atexit";
8163     }
8164
8165   /* Now, build the function declaration.  */
8166   push_lang_context (lang_name_c);
8167   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8168   mark_used (atexit_fndecl);
8169   pop_lang_context ();
8170   atexit_node = default_conversion (atexit_fndecl);
8171
8172   return atexit_node;
8173 }
8174
8175 /* Returns the __dso_handle VAR_DECL.  */
8176
8177 static tree
8178 get_dso_handle_node ()
8179 {
8180   if (dso_handle_node)
8181     return dso_handle_node;
8182
8183   /* Declare the variable.  */
8184   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8185                                         ptr_type_node);
8186
8187   return dso_handle_node;
8188 }
8189
8190 /* Begin a new function with internal linkage whose job will be simply
8191    to destroy some particular variable.  */
8192
8193 static tree
8194 start_cleanup_fn ()
8195 {
8196   static int counter = 0;
8197   int old_interface_unknown = interface_unknown;
8198   char name[32];
8199   tree parmtypes;
8200   tree fntype;
8201   tree fndecl;
8202
8203   push_to_top_level ();
8204
8205   /* No need to mangle this.  */
8206   push_lang_context (lang_name_c);
8207
8208   interface_unknown = 1;
8209
8210   /* Build the parameter-types.  */
8211   parmtypes = void_list_node;
8212   /* Functions passed to __cxa_atexit take an additional parameter.
8213      We'll just ignore it.  After we implement the new calling
8214      convention for destructors, we can eliminate the use of
8215      additional cleanup functions entirely in the -fnew-abi case.  */
8216   if (flag_use_cxa_atexit)
8217     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8218   /* Build the function type itself.  */
8219   fntype = build_function_type (void_type_node, parmtypes);
8220   /* Build the name of the function.  */
8221   sprintf (name, "__tcf_%d", counter++);
8222   /* Build the function declaration.  */
8223   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8224   /* It's a function with internal linkage, generated by the
8225      compiler.  */
8226   TREE_PUBLIC (fndecl) = 0;
8227   DECL_ARTIFICIAL (fndecl) = 1;
8228   /* Build the parameter.  */
8229   if (flag_use_cxa_atexit)
8230     {
8231       tree parmdecl;
8232
8233       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8234       DECL_CONTEXT (parmdecl) = fndecl;
8235       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8236       TREE_USED (parmdecl) = 1;
8237       DECL_ARGUMENTS (fndecl) = parmdecl;
8238     }
8239
8240   pushdecl (fndecl);
8241   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8242   do_pushlevel ();
8243
8244   interface_unknown = old_interface_unknown;
8245
8246   pop_lang_context ();
8247
8248   return current_function_decl;
8249 }
8250
8251 /* Finish the cleanup function begun by start_cleanup_fn.  */
8252
8253 static void
8254 end_cleanup_fn ()
8255 {
8256   do_poplevel ();
8257
8258   expand_body (finish_function (lineno, 0));
8259
8260   pop_from_top_level ();
8261 }
8262
8263 /* Generate code to handle the destruction of DECL, an object with
8264    static storage duration.  */
8265
8266 void
8267 register_dtor_fn (decl)
8268      tree decl;
8269 {
8270   tree cleanup;
8271   tree compound_stmt;
8272   tree args;
8273   tree fcall;
8274
8275   int saved_flag_access_control;
8276
8277   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8278     return;
8279
8280   /* Call build_cleanup before we enter the anonymous function so that
8281      any access checks will be done relative to the current scope,
8282      rather than the scope of the anonymous function.  */
8283   build_cleanup (decl);
8284
8285   /* Now start the function.  */
8286   cleanup = start_cleanup_fn ();
8287
8288   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8289      to the original function, rather than the anonymous one.  That
8290      will make the back-end think that nested functions are in use,
8291      which causes confusion.  */
8292   saved_flag_access_control = flag_access_control;
8293   flag_access_control = 0;
8294   fcall = build_cleanup (decl);
8295   flag_access_control = saved_flag_access_control;
8296
8297   /* Create the body of the anonymous function.  */
8298   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8299   finish_expr_stmt (fcall);
8300   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8301   end_cleanup_fn ();
8302
8303   /* Call atexit with the cleanup function.  */
8304   mark_addressable (cleanup);
8305   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8306   if (flag_use_cxa_atexit)
8307     {
8308       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8309       args = tree_cons (NULL_TREE, null_pointer_node, args);
8310       args = tree_cons (NULL_TREE, cleanup, args);
8311     }
8312   else
8313     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8314   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8315 }
8316
8317 void
8318 expand_static_init (decl, init)
8319      tree decl;
8320      tree init;
8321 {
8322   tree oldstatic = value_member (decl, static_aggregates);
8323
8324   if (oldstatic)
8325     {
8326       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8327         cp_error ("multiple initializations given for `%D'", decl);
8328     }
8329   else if (! toplevel_bindings_p ())
8330     {
8331       /* Emit code to perform this initialization but once.  */
8332       tree temp;
8333       tree if_stmt;
8334       tree then_clause;
8335       tree assignment;
8336       tree temp_init;
8337
8338       /* Emit code to perform this initialization but once.  This code
8339          looks like:
8340
8341            static int temp = 0;
8342            if (!temp) {
8343              // Do initialization.
8344              temp = 1;
8345              // Register variable for destruction at end of program.
8346            }
8347
8348          Note that the `temp' variable is only set to 1 *after* the
8349          initialization is complete.  This ensures that an exception,
8350          thrown during the construction, will cause the variable to
8351          reinitialized when we pass through this code again, as per:
8352
8353            [stmt.dcl]
8354
8355            If the initialization exits by throwing an exception, the
8356            initialization is not complete, so it will be tried again
8357            the next time control enters the declaration.
8358
8359          In theory, this process should be thread-safe, too; multiple
8360          threads should not be able to initialize the variable more
8361          than once.  We don't yet attempt to ensure thread-safety.  */
8362       temp = get_temp_name (integer_type_node, 1);
8363       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8364
8365       /* Begin the conditional initialization.  */
8366       if_stmt = begin_if_stmt ();
8367       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8368                                             integer_zero_node),
8369                            if_stmt);
8370       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8371
8372       /* Do the initialization itself.  */
8373       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8374           || (init && TREE_CODE (init) == TREE_LIST))
8375         assignment = build_aggr_init (decl, init, 0);
8376       else if (init)
8377         /* The initialization we're doing here is just a bitwise
8378            copy.  */
8379         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8380       else
8381         assignment = NULL_TREE;
8382
8383       /* Once the assignment is complete, set TEMP to 1.  Since the
8384          construction of the static object is complete at this point,
8385          we want to make sure TEMP is set to 1 even if a temporary
8386          constructed during the initialization throws an exception
8387          when it is destroyed.  So, we combine the initialization and
8388          the assignment to TEMP into a single expression, ensuring
8389          that when we call finish_expr_stmt the cleanups will not be
8390          run until after TEMP is set to 1.  */
8391       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8392       if (assignment)
8393         {
8394           assignment = tree_cons (NULL_TREE, assignment,
8395                                   build_tree_list (NULL_TREE,
8396                                                    temp_init));
8397           assignment = build_compound_expr (assignment);
8398         }
8399       else
8400         assignment = temp_init;
8401       finish_expr_stmt (assignment);
8402
8403       /* Use atexit to register a function for destroying this static
8404          variable.  */
8405       register_dtor_fn (decl);
8406
8407       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8408       finish_then_clause (if_stmt);
8409       finish_if_stmt ();
8410     }
8411   else
8412     static_aggregates = tree_cons (init, decl, static_aggregates);
8413 }
8414
8415 /* Finish the declaration of a catch-parameter.  */
8416
8417 tree
8418 start_handler_parms (declspecs, declarator)
8419      tree declspecs;
8420      tree declarator;
8421 {
8422   tree decl;
8423   if (declspecs)
8424     {
8425       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8426                              1, NULL_TREE);
8427       if (decl == NULL_TREE)
8428         error ("invalid catch parameter");
8429     }
8430   else
8431     decl = NULL_TREE;
8432
8433   return decl;
8434 }
8435
8436 \f
8437 /* Make TYPE a complete type based on INITIAL_VALUE.
8438    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8439    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8440
8441 int
8442 complete_array_type (type, initial_value, do_default)
8443      tree type, initial_value;
8444      int do_default;
8445 {
8446   register tree maxindex = NULL_TREE;
8447   int value = 0;
8448
8449   if (initial_value)
8450     {
8451       /* Note MAXINDEX  is really the maximum index,
8452          one less than the size.  */
8453       if (TREE_CODE (initial_value) == STRING_CST)
8454         {
8455           int eltsize
8456             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8457           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8458                                    / eltsize) - 1, 0);
8459         }
8460       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8461         {
8462           tree elts = CONSTRUCTOR_ELTS (initial_value);
8463
8464           maxindex = ssize_int (-1);
8465           for (; elts; elts = TREE_CHAIN (elts))
8466             {
8467               if (TREE_PURPOSE (elts))
8468                 maxindex = TREE_PURPOSE (elts);
8469               else
8470                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8471             }
8472           maxindex = copy_node (maxindex);
8473         }
8474       else
8475         {
8476           /* Make an error message unless that happened already.  */
8477           if (initial_value != error_mark_node)
8478             value = 1;
8479           else
8480             initial_value = NULL_TREE;
8481
8482           /* Prevent further error messages.  */
8483           maxindex = build_int_2 (0, 0);
8484         }
8485     }
8486
8487   if (!maxindex)
8488     {
8489       if (do_default)
8490         maxindex = build_int_2 (0, 0);
8491       value = 2;
8492     }
8493
8494   if (maxindex)
8495     {
8496       tree itype;
8497       tree domain;
8498
8499       domain = build_index_type (maxindex);
8500       TYPE_DOMAIN (type) = domain;
8501
8502       if (! TREE_TYPE (maxindex))
8503         TREE_TYPE (maxindex) = domain;
8504       if (initial_value)
8505         itype = TREE_TYPE (initial_value);
8506       else
8507         itype = NULL;
8508       if (itype && !TYPE_DOMAIN (itype))
8509         TYPE_DOMAIN (itype) = domain;
8510       /* The type of the main variant should never be used for arrays
8511          of different sizes.  It should only ever be completed with the
8512          size of the array.  */
8513       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8514         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8515     }
8516
8517   /* Lay out the type now that we can get the real answer.  */
8518
8519   layout_type (type);
8520
8521   return value;
8522 }
8523 \f
8524 /* Return zero if something is declared to be a member of type
8525    CTYPE when in the context of CUR_TYPE.  STRING is the error
8526    message to print in that case.  Otherwise, quietly return 1.  */
8527
8528 static int
8529 member_function_or_else (ctype, cur_type, flags)
8530      tree ctype, cur_type;
8531      enum overload_flags flags;
8532 {
8533   if (ctype && ctype != cur_type)
8534     {
8535       if (flags == DTOR_FLAG)
8536         error ("destructor for alien class `%s' cannot be a member",
8537                TYPE_NAME_STRING (ctype));
8538       else
8539         error ("constructor for alien class `%s' cannot be a member",
8540                TYPE_NAME_STRING (ctype));
8541       return 0;
8542     }
8543   return 1;
8544 }
8545 \f
8546 /* Subroutine of `grokdeclarator'.  */
8547
8548 /* Generate errors possibly applicable for a given set of specifiers.
8549    This is for ARM $7.1.2.  */
8550
8551 static void
8552 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8553      tree object;
8554      const char *type;
8555      int virtualp, quals, friendp, raises, inlinep;
8556 {
8557   if (virtualp)
8558     cp_error ("`%D' declared as a `virtual' %s", object, type);
8559   if (inlinep)
8560     cp_error ("`%D' declared as an `inline' %s", object, type);
8561   if (quals)
8562     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8563               object, type);
8564   if (friendp)
8565     cp_error_at ("`%D' declared as a friend", object);
8566   if (raises)
8567     cp_error_at ("`%D' declared with an exception specification", object);
8568 }
8569
8570 /* CTYPE is class type, or null if non-class.
8571    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8572    or METHOD_TYPE.
8573    DECLARATOR is the function's name.
8574    VIRTUALP is truthvalue of whether the function is virtual or not.
8575    FLAGS are to be passed through to `grokclassfn'.
8576    QUALS are qualifiers indicating whether the function is `const'
8577    or `volatile'.
8578    RAISES is a list of exceptions that this function can raise.
8579    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8580    not look, and -1 if we should not call `grokclassfn' at all.
8581
8582    Returns `NULL_TREE' if something goes wrong, after issuing
8583    applicable error messages.  */
8584
8585 static tree
8586 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8587             raises, check, friendp, publicp, inlinep, funcdef_flag,
8588             template_count, in_namespace)
8589      tree ctype, type;
8590      tree declarator;
8591      tree orig_declarator;
8592      int virtualp;
8593      enum overload_flags flags;
8594      tree quals, raises;
8595      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8596      tree in_namespace;
8597 {
8598   tree cname, decl;
8599   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8600   int has_default_arg = 0;
8601   tree t;
8602
8603   if (ctype)
8604     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8605       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8606   else
8607     cname = NULL_TREE;
8608
8609   if (raises)
8610     {
8611       type = build_exception_variant (type, raises);
8612     }
8613
8614   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8615   /* Propagate volatile out from type to decl. */
8616   if (TYPE_VOLATILE (type))
8617     TREE_THIS_VOLATILE (decl) = 1;
8618
8619   /* If this decl has namespace scope, set that up.  */
8620   if (in_namespace)
8621     set_decl_namespace (decl, in_namespace, friendp);
8622   else if (publicp && ! ctype)
8623     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8624
8625   /* `main' and builtins have implicit 'C' linkage.  */
8626   if ((MAIN_NAME_P (declarator)
8627        || (IDENTIFIER_LENGTH (declarator) > 10
8628            && IDENTIFIER_POINTER (declarator)[0] == '_'
8629            && IDENTIFIER_POINTER (declarator)[1] == '_'
8630            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8631       && current_lang_name == lang_name_cplusplus
8632       && ctype == NULL_TREE
8633       /* NULL_TREE means global namespace.  */
8634       && DECL_CONTEXT (decl) == NULL_TREE)
8635     DECL_LANGUAGE (decl) = lang_c;
8636
8637   /* Should probably propagate const out from type to decl I bet (mrs).  */
8638   if (staticp)
8639     {
8640       DECL_STATIC_FUNCTION_P (decl) = 1;
8641       DECL_CONTEXT (decl) = ctype;
8642     }
8643
8644   if (ctype)
8645     DECL_CONTEXT (decl) = ctype;
8646
8647   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8648     {
8649       if (processing_template_decl)
8650         error ("cannot declare `::main' to be a template");
8651       if (inlinep)
8652         error ("cannot declare `::main' to be inline");
8653       else if (! publicp)
8654         error ("cannot declare `::main' to be static");
8655       inlinep = 0;
8656       publicp = 1;
8657     }
8658
8659   /* Members of anonymous types and local classes have no linkage; make
8660      them internal.  */
8661   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8662                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8663     publicp = 0;
8664
8665   if (publicp)
8666     {
8667       /* [basic.link]: A name with no linkage (notably, the name of a class
8668          or enumeration declared in a local scope) shall not be used to
8669          declare an entity with linkage.
8670
8671          Only check this for public decls for now.  */
8672       t = no_linkage_check (TREE_TYPE (decl));
8673       if (t)
8674         {
8675           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8676             {
8677               if (DECL_LANGUAGE (decl) == lang_c)
8678                 /* Allow this; it's pretty common in C.  */;
8679               else
8680                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8681                             decl);
8682             }
8683           else
8684             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8685                         decl, t);
8686         }
8687     }
8688
8689   TREE_PUBLIC (decl) = publicp;
8690   if (! publicp)
8691     {
8692       DECL_INTERFACE_KNOWN (decl) = 1;
8693       DECL_NOT_REALLY_EXTERN (decl) = 1;
8694     }
8695
8696   if (inlinep)
8697     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8698
8699   DECL_EXTERNAL (decl) = 1;
8700   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8701     {
8702       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8703                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8704       quals = NULL_TREE;
8705     }
8706
8707   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8708     grok_op_properties (decl, virtualp, check < 0);
8709
8710   if (ctype && decl_function_context (decl))
8711     DECL_NO_STATIC_CHAIN (decl) = 1;
8712
8713   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8714     if (TREE_PURPOSE (t)
8715         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8716       {
8717         has_default_arg = 1;
8718         break;
8719       }
8720
8721   if (friendp
8722       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8723     {
8724       if (funcdef_flag)
8725         cp_error
8726           ("defining explicit specialization `%D' in friend declaration",
8727            orig_declarator);
8728       else
8729         {
8730           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8731             {
8732               /* Something like `template <class T> friend void f<T>()'.  */
8733               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8734                         orig_declarator);
8735               return NULL_TREE;
8736             }
8737
8738
8739           /* A friend declaration of the form friend void f<>().  Record
8740              the information in the TEMPLATE_ID_EXPR.  */
8741           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8742           DECL_TEMPLATE_INFO (decl)
8743             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8744                          TREE_OPERAND (orig_declarator, 1),
8745                          NULL_TREE);
8746
8747           if (has_default_arg)
8748             {
8749               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8750                         decl);
8751               return NULL_TREE;
8752             }
8753
8754           if (inlinep)
8755             {
8756               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8757                         decl);
8758               return NULL_TREE;
8759             }
8760         }
8761     }
8762
8763   if (has_default_arg)
8764     add_defarg_fn (decl);
8765
8766   /* Plain overloading: will not be grok'd by grokclassfn.  */
8767   if (! ctype && ! processing_template_decl
8768       && DECL_LANGUAGE (decl) != lang_c
8769       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8770     set_mangled_name_for_decl (decl);
8771
8772   if (funcdef_flag)
8773     /* Make the init_value nonzero so pushdecl knows this is not
8774        tentative.  error_mark_node is replaced later with the BLOCK.  */
8775     DECL_INITIAL (decl) = error_mark_node;
8776
8777   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8778     TREE_NOTHROW (decl) = 1;
8779
8780   /* Caller will do the rest of this.  */
8781   if (check < 0)
8782     return decl;
8783
8784   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8785     DECL_CONSTRUCTOR_P (decl) = 1;
8786
8787   /* Function gets the ugly name, field gets the nice one.  This call
8788      may change the type of the function (because of default
8789      parameters)!  */
8790   if (ctype != NULL_TREE)
8791     grokclassfn (ctype, decl, flags, quals);
8792
8793   decl = check_explicit_specialization (orig_declarator, decl,
8794                                         template_count,
8795                                         2 * (funcdef_flag != 0) +
8796                                         4 * (friendp != 0));
8797   if (decl == error_mark_node)
8798     return NULL_TREE;
8799
8800   if (ctype != NULL_TREE
8801       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8802       && check)
8803     {
8804       tree old_decl;
8805
8806       old_decl = check_classfn (ctype, decl);
8807
8808       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8809         /* Because grokfndecl is always supposed to return a
8810            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8811            here.  We depend on our callers to figure out that its
8812            really a template that's being returned.  */
8813         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8814
8815       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8816           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8817         {
8818           /* Remove the `this' parm added by grokclassfn.
8819              XXX Isn't this done in start_function, too?  */
8820           revert_static_member_fn (decl);
8821           last_function_parms = TREE_CHAIN (last_function_parms);
8822         }
8823       if (old_decl && DECL_ARTIFICIAL (old_decl))
8824         cp_error ("definition of implicitly-declared `%D'", old_decl);
8825
8826       if (old_decl)
8827         {
8828           /* Since we've smashed OLD_DECL to its
8829              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8830           if (TREE_CODE (decl) == TEMPLATE_DECL)
8831             decl = DECL_TEMPLATE_RESULT (decl);
8832
8833           /* Attempt to merge the declarations.  This can fail, in
8834              the case of some illegal specialization declarations.  */
8835           if (!duplicate_decls (decl, old_decl))
8836             cp_error ("no `%#D' member function declared in class `%T'",
8837                       decl, ctype);
8838           return old_decl;
8839         }
8840     }
8841
8842   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8843     return NULL_TREE;
8844
8845   if (ctype == NULL_TREE || check)
8846     return decl;
8847
8848   if (virtualp)
8849     {
8850       DECL_VIRTUAL_P (decl) = 1;
8851       if (DECL_VINDEX (decl) == NULL_TREE)
8852         DECL_VINDEX (decl) = error_mark_node;
8853       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8854     }
8855
8856   return decl;
8857 }
8858
8859 static tree
8860 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8861      tree type;
8862      tree declarator;
8863      RID_BIT_TYPE *specbits_in;
8864      int initialized;
8865      int constp;
8866      tree in_namespace;
8867 {
8868   tree decl;
8869   RID_BIT_TYPE specbits;
8870
8871   specbits = *specbits_in;
8872
8873   if (TREE_CODE (type) == OFFSET_TYPE)
8874     {
8875       /* If you declare a static member so that it
8876          can be initialized, the code will reach here.  */
8877       tree basetype = TYPE_OFFSET_BASETYPE (type);
8878       type = TREE_TYPE (type);
8879       decl = build_lang_decl (VAR_DECL, declarator, type);
8880       DECL_CONTEXT (decl) = basetype;
8881       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8882     }
8883   else
8884     {
8885       tree context;
8886
8887       if (in_namespace)
8888         context = in_namespace;
8889       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8890         context = current_namespace;
8891       else
8892         context = NULL_TREE;
8893
8894       if (processing_template_decl)
8895         /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8896            we can call push_template_decl.  */
8897         decl = build_lang_decl (VAR_DECL, declarator, type);
8898       else
8899         decl = build_decl (VAR_DECL, declarator, type);
8900
8901       if (context)
8902         set_decl_namespace (decl, context, 0);
8903
8904       context = DECL_CONTEXT (decl);
8905       if (declarator && context && current_lang_name != lang_name_c)
8906         DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8907     }
8908
8909   if (in_namespace)
8910     set_decl_namespace (decl, in_namespace, 0);
8911
8912   if (RIDBIT_SETP (RID_EXTERN, specbits))
8913     {
8914       DECL_THIS_EXTERN (decl) = 1;
8915       DECL_EXTERNAL (decl) = !initialized;
8916     }
8917
8918   /* In class context, static means one per class,
8919      public access, and static storage.  */
8920   if (DECL_CLASS_SCOPE_P (decl))
8921     {
8922       TREE_PUBLIC (decl) = 1;
8923       TREE_STATIC (decl) = 1;
8924       DECL_EXTERNAL (decl) = 0;
8925     }
8926   /* At top level, either `static' or no s.c. makes a definition
8927      (perhaps tentative), and absence of `static' makes it public.  */
8928   else if (toplevel_bindings_p ())
8929     {
8930       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8931                             && (DECL_THIS_EXTERN (decl) || ! constp));
8932       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8933     }
8934   /* Not at top level, only `static' makes a static definition.  */
8935   else
8936     {
8937       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8938       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8939     }
8940
8941   if (TREE_PUBLIC (decl))
8942     {
8943       /* [basic.link]: A name with no linkage (notably, the name of a class
8944          or enumeration declared in a local scope) shall not be used to
8945          declare an entity with linkage.
8946
8947          Only check this for public decls for now.  */
8948       tree t = no_linkage_check (TREE_TYPE (decl));
8949       if (t)
8950         {
8951           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8952             /* Ignore for now; `enum { foo } e' is pretty common.  */;
8953           else
8954             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8955                         decl, t);
8956         }
8957     }
8958
8959   return decl;
8960 }
8961
8962 /* Create and return a canonical pointer to member function type, for
8963    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
8964
8965 tree
8966 build_ptrmemfunc_type (type)
8967      tree type;
8968 {
8969   tree fields[4];
8970   tree t;
8971   tree u;
8972   tree unqualified_variant = NULL_TREE;
8973
8974   /* If a canonical type already exists for this type, use it.  We use
8975      this method instead of type_hash_canon, because it only does a
8976      simple equality check on the list of field members.  */
8977
8978   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8979     return t;
8980
8981   /* Make sure that we always have the unqualified pointer-to-member
8982      type first.  */
8983   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8984     unqualified_variant
8985       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
8986
8987   t = make_aggr_type (RECORD_TYPE);
8988   /* Let the front-end know this is a pointer to member function...  */
8989   TYPE_PTRMEMFUNC_FLAG (t) = 1;
8990   /* ... and not really an aggregate.  */
8991   SET_IS_AGGR_TYPE (t, 0);
8992
8993   if (!flag_new_abi)
8994     {
8995       u = make_aggr_type (UNION_TYPE);
8996       SET_IS_AGGR_TYPE (u, 0);
8997       fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
8998       fields[1] = build_lang_decl (FIELD_DECL, delta2_identifier,
8999                                    delta_type_node);
9000       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9001       TYPE_NAME (u) = NULL_TREE;
9002
9003       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
9004                                    delta_type_node);
9005       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
9006                                    delta_type_node);
9007       fields[2] = build_lang_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9008       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9009     }
9010   else
9011     {
9012       fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
9013       fields[1] = build_lang_decl (FIELD_DECL, delta_identifier,
9014                                    delta_type_node);
9015       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9016     }
9017
9018   /* Zap out the name so that the back-end will give us the debugging
9019      information for this anonymous RECORD_TYPE.  */
9020   TYPE_NAME (t) = NULL_TREE;
9021
9022   /* If this is not the unqualified form of this pointer-to-member
9023      type, set the TYPE_MAIN_VARIANT for this type to be the
9024      unqualified type.  Since they are actually RECORD_TYPEs that are
9025      not variants of each other, we must do this manually.  */
9026   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9027     {
9028       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9029       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9030       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9031       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9032     }
9033
9034   /* Cache this pointer-to-member type so that we can find it again
9035      later.  */
9036   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9037
9038   /* Seems to be wanted.  */
9039   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9040
9041   return t;
9042 }
9043
9044 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9045    Check to see that the definition is valid.  Issue appropriate error
9046    messages.  Return 1 if the definition is particularly bad, or 0
9047    otherwise.  */
9048
9049 int
9050 check_static_variable_definition (decl, type)
9051      tree decl;
9052      tree type;
9053 {
9054   /* Motion 10 at San Diego: If a static const integral data member is
9055      initialized with an integral constant expression, the initializer
9056      may appear either in the declaration (within the class), or in
9057      the definition, but not both.  If it appears in the class, the
9058      member is a member constant.  The file-scope definition is always
9059      required.  */
9060   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9061     {
9062       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9063                 type);
9064       /* If we just return the declaration, crashes will sometimes
9065          occur.  We therefore return void_type_node, as if this was a
9066          friend declaration, to cause callers to completely ignore
9067          this declaration.  */
9068       return 1;
9069     }
9070   else if (!CP_TYPE_CONST_P (type))
9071     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9072               decl);
9073   else if (pedantic && !INTEGRAL_TYPE_P (type))
9074     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9075
9076   return 0;
9077 }
9078
9079 /* Given the SIZE (i.e., number of elements) in an array, compute an
9080    appropriate index type for the array.  If non-NULL, NAME is the
9081    name of the thing being declared.  */
9082
9083 tree
9084 compute_array_index_type (name, size)
9085      tree name;
9086      tree size;
9087 {
9088   tree itype;
9089
9090   /* The size might be the result of a cast. */
9091   STRIP_TYPE_NOPS (size);
9092
9093   /* It might be a const variable or enumeration constant.  */
9094   if (TREE_READONLY_DECL_P (size))
9095     size = decl_constant_value (size);
9096
9097   /* If this involves a template parameter, it will be a constant at
9098      instantiation time, but we don't know what the value is yet.
9099      Even if no template parameters are involved, we may an expression
9100      that is not a constant; we don't even simplify `1 + 2' when
9101      processing a template.  */
9102   if (processing_template_decl)
9103     {
9104       /* Resolve a qualified reference to an enumerator or static
9105          const data member of ours.  */
9106       if (TREE_CODE (size) == SCOPE_REF
9107           && TREE_OPERAND (size, 0) == current_class_type)
9108         {
9109           tree t = lookup_field (current_class_type,
9110                                  TREE_OPERAND (size, 1), 0, 0);
9111           if (t)
9112             size = t;
9113         }
9114
9115       return build_index_type (build_min (MINUS_EXPR, sizetype,
9116                                           size, integer_one_node));
9117     }
9118
9119   /* The array bound must be an integer type.  */
9120   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9121       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9122       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9123     {
9124       if (name)
9125         cp_error ("size of array `%D' has non-integer type", name);
9126       else
9127         cp_error ("size of array has non-integer type");
9128       size = integer_one_node;
9129     }
9130
9131   /* Normally, the array-bound will be a constant.  */
9132   if (TREE_CONSTANT (size))
9133     {
9134       /* Check to see if the array bound overflowed.  Make that an
9135          error, no matter how generous we're being.  */
9136       int old_flag_pedantic_errors = flag_pedantic_errors;
9137       int old_pedantic = pedantic;
9138       pedantic = flag_pedantic_errors = 1;
9139       constant_expression_warning (size);
9140       pedantic = old_pedantic;
9141       flag_pedantic_errors = old_flag_pedantic_errors;
9142
9143       /* An array must have a positive number of elements.  */
9144       if (INT_CST_LT (size, integer_zero_node))
9145         {
9146           if (name)
9147             cp_error ("size of array `%D' is negative", name);
9148           else
9149             cp_error ("size of array is negative");
9150           size = integer_one_node;
9151         }
9152       /* Except that an extension we allow zero-sized arrays.  We
9153          always allow them in system headers because glibc uses
9154          them.  */
9155       else if (integer_zerop (size) && pedantic && !in_system_header)
9156         {
9157           if (name)
9158             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9159           else
9160             cp_pedwarn ("ISO C++ forbids zero-size array");
9161         }
9162     }
9163
9164   /* Compute the index of the largest element in the array.  It is
9165      one less than the number of elements in the array.  */
9166   itype
9167     = fold (build_binary_op (MINUS_EXPR,
9168                              cp_convert (ssizetype, size),
9169                              cp_convert (ssizetype,
9170                                          integer_one_node)));
9171
9172   /* Check for variable-sized arrays.  We allow such things as an
9173      extension, even though they are not allowed in ANSI/ISO C++.  */
9174   if (!TREE_CONSTANT (itype))
9175     {
9176       if (pedantic)
9177         {
9178           if (name)
9179             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9180                         name);
9181           else
9182             cp_pedwarn ("ISO C++ forbids variable-size array");
9183         }
9184
9185       /* Create a variable-sized array index type.  */
9186       itype = variable_size (itype);
9187     }
9188   /* Make sure that there was no overflow when creating to a signed
9189      index type.  (For example, on a 32-bit machine, an array with
9190      size 2^32 - 1 is too big.)  */
9191   else if (TREE_OVERFLOW (itype))
9192     {
9193       error ("overflow in array dimension");
9194       TREE_OVERFLOW (itype) = 0;
9195     }
9196
9197   /* Create and return the appropriate index type.  */
9198   return build_index_type (itype);
9199 }
9200
9201 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9202    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9203    with this type.  */
9204
9205 static tree
9206 create_array_type_for_decl (name, type, size)
9207      tree name;
9208      tree type;
9209      tree size;
9210 {
9211   tree itype = NULL_TREE;
9212   const char* error_msg;
9213
9214   /* If things have already gone awry, bail now.  */
9215   if (type == error_mark_node || size == error_mark_node)
9216     return error_mark_node;
9217
9218   /* Assume that everything will go OK.  */
9219   error_msg = NULL;
9220
9221   /* There are some types which cannot be array elements.  */
9222   switch (TREE_CODE (type))
9223     {
9224     case VOID_TYPE:
9225       error_msg = "array of void";
9226       break;
9227
9228     case FUNCTION_TYPE:
9229       error_msg = "array of functions";
9230       break;
9231
9232     case REFERENCE_TYPE:
9233       error_msg = "array of references";
9234       break;
9235
9236     case OFFSET_TYPE:
9237       error_msg = "array of data members";
9238       break;
9239
9240     case METHOD_TYPE:
9241       error_msg = "array of function members";
9242       break;
9243
9244     default:
9245       break;
9246     }
9247
9248   /* If something went wrong, issue an error-message and return.  */
9249   if (error_msg)
9250     {
9251       if (name)
9252         cp_error ("declaration of `%D' as %s", name, error_msg);
9253       else
9254         cp_error ("creating %s", error_msg);
9255
9256       return error_mark_node;
9257     }
9258
9259   /* [dcl.array]
9260
9261      The constant expressions that specify the bounds of the arrays
9262      can be omitted only for the first member of the sequence.  */
9263   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9264     {
9265       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9266                 name);
9267
9268       return error_mark_node;
9269     }
9270
9271   /* Figure out the index type for the array.  */
9272   if (size)
9273     itype = compute_array_index_type (name, size);
9274
9275   return build_cplus_array_type (type, itype);
9276 }
9277
9278 /* Given declspecs and a declarator,
9279    determine the name and type of the object declared
9280    and construct a ..._DECL node for it.
9281    (In one case we can return a ..._TYPE node instead.
9282     For invalid input we sometimes return 0.)
9283
9284    DECLSPECS is a chain of tree_list nodes whose value fields
9285     are the storage classes and type specifiers.
9286
9287    DECL_CONTEXT says which syntactic context this declaration is in:
9288      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9289      FUNCDEF for a function definition.  Like NORMAL but a few different
9290       error messages in each case.  Return value may be zero meaning
9291       this definition is too screwy to try to parse.
9292      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9293       handle member functions (which have FIELD context).
9294       Return value may be zero meaning this definition is too screwy to
9295       try to parse.
9296      PARM for a parameter declaration (either within a function prototype
9297       or before a function body).  Make a PARM_DECL, or return void_type_node.
9298      CATCHPARM for a parameter declaration before a catch clause.
9299      TYPENAME if for a typename (in a cast or sizeof).
9300       Don't make a DECL node; just return the ..._TYPE node.
9301      FIELD for a struct or union field; make a FIELD_DECL.
9302      BITFIELD for a field with specified width.
9303    INITIALIZED is 1 if the decl has an initializer.
9304
9305    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9306    normal attributes in TREE_PURPOSE, or NULL_TREE.
9307
9308    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9309    It may also be so in the PARM case, for a prototype where the
9310    argument type is specified but not the name.
9311
9312    This function is where the complicated C meanings of `static'
9313    and `extern' are interpreted.
9314
9315    For C++, if there is any monkey business to do, the function which
9316    calls this one must do it, i.e., prepending instance variables,
9317    renaming overloaded function names, etc.
9318
9319    Note that for this C++, it is an error to define a method within a class
9320    which does not belong to that class.
9321
9322    Except in the case where SCOPE_REFs are implicitly known (such as
9323    methods within a class being redundantly qualified),
9324    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9325    (class_name::decl_name).  The caller must also deal with this.
9326
9327    If a constructor or destructor is seen, and the context is FIELD,
9328    then the type gains the attribute TREE_HAS_x.  If such a declaration
9329    is erroneous, NULL_TREE is returned.
9330
9331    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9332    function, these are the qualifiers to give to the `this' pointer. We
9333    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9334
9335    May return void_type_node if the declarator turned out to be a friend.
9336    See grokfield for details.  */
9337
9338 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
9339
9340 tree
9341 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9342      tree declspecs;
9343      tree declarator;
9344      enum decl_context decl_context;
9345      int initialized;
9346      tree attrlist;
9347 {
9348   RID_BIT_TYPE specbits;
9349   int nclasses = 0;
9350   tree spec;
9351   tree type = NULL_TREE;
9352   int longlong = 0;
9353   int constp;
9354   int restrictp;
9355   int volatilep;
9356   int type_quals;
9357   int virtualp, explicitp, friendp, inlinep, staticp;
9358   int explicit_int = 0;
9359   int explicit_char = 0;
9360   int defaulted_int = 0;
9361   tree typedef_decl = NULL_TREE;
9362   const char *name;
9363   tree typedef_type = NULL_TREE;
9364   int funcdef_flag = 0;
9365   enum tree_code innermost_code = ERROR_MARK;
9366   int bitfield = 0;
9367 #if 0
9368   /* See the code below that used this.  */
9369   tree decl_machine_attr = NULL_TREE;
9370 #endif
9371   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9372      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9373   tree init = NULL_TREE;
9374
9375   /* Keep track of what sort of function is being processed
9376      so that we can warn about default return values, or explicit
9377      return values which do not match prescribed defaults.  */
9378   enum return_types return_type = return_normal;
9379
9380   tree dname = NULL_TREE;
9381   tree ctype = current_class_type;
9382   tree ctor_return_type = NULL_TREE;
9383   enum overload_flags flags = NO_SPECIAL;
9384   tree quals = NULL_TREE;
9385   tree raises = NULL_TREE;
9386   int template_count = 0;
9387   tree in_namespace = NULL_TREE;
9388   tree inner_attrs;
9389   int ignore_attrs;
9390
9391   RIDBIT_RESET_ALL (specbits);
9392   if (decl_context == FUNCDEF)
9393     funcdef_flag = 1, decl_context = NORMAL;
9394   else if (decl_context == MEMFUNCDEF)
9395     funcdef_flag = -1, decl_context = FIELD;
9396   else if (decl_context == BITFIELD)
9397     bitfield = 1, decl_context = FIELD;
9398
9399   /* Look inside a declarator for the name being declared
9400      and get it as a string, for an error message.  */
9401   {
9402     tree *next = &declarator;
9403     register tree decl;
9404     name = NULL;
9405
9406     while (next && *next)
9407       {
9408         decl = *next;
9409         switch (TREE_CODE (decl))
9410           {
9411           case TREE_LIST:
9412             /* For attributes.  */
9413             next = &TREE_VALUE (decl);
9414             break;
9415
9416           case COND_EXPR:
9417             ctype = NULL_TREE;
9418             next = &TREE_OPERAND (decl, 0);
9419             break;
9420
9421           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9422             {
9423               tree name = TREE_OPERAND (decl, 0);
9424               tree rename = NULL_TREE;
9425
9426               my_friendly_assert (flags == NO_SPECIAL, 152);
9427               flags = DTOR_FLAG;
9428               return_type = return_dtor;
9429               if (TREE_CODE (name) == TYPE_DECL)
9430                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9431               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9432               if (ctype == NULL_TREE)
9433                 {
9434                   if (current_class_type == NULL_TREE)
9435                     {
9436                       error ("destructors must be member functions");
9437                       flags = NO_SPECIAL;
9438                     }
9439                   else
9440                     {
9441                       tree t = constructor_name (current_class_name);
9442                       if (t != name)
9443                         rename = t;
9444                     }
9445                 }
9446               else
9447                 {
9448                   tree t = constructor_name (ctype);
9449                   if (t != name)
9450                     rename = t;
9451                 }
9452
9453               if (rename)
9454                 {
9455                   cp_error ("destructor `%T' must match class name `%T'",
9456                             name, rename);
9457                   TREE_OPERAND (decl, 0) = rename;
9458                 }
9459               next = &name;
9460             }
9461             break;
9462
9463           case ADDR_EXPR:       /* C++ reference declaration */
9464             /* Fall through. */
9465           case ARRAY_REF:
9466           case INDIRECT_REF:
9467             ctype = NULL_TREE;
9468             innermost_code = TREE_CODE (decl);
9469             next = &TREE_OPERAND (decl, 0);
9470             break;
9471
9472           case CALL_EXPR:
9473             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9474               {
9475                 /* This is actually a variable declaration using
9476                    constructor syntax.  We need to call start_decl and
9477                    cp_finish_decl so we can get the variable
9478                    initialized...  */
9479
9480                 tree attributes, prefix_attributes;
9481
9482                 *next = TREE_OPERAND (decl, 0);
9483                 init = CALL_DECLARATOR_PARMS (decl);
9484
9485                 if (attrlist)
9486                   {
9487                     attributes = TREE_PURPOSE (attrlist);
9488                     prefix_attributes = TREE_VALUE (attrlist);
9489                   }
9490                 else
9491                   {
9492                     attributes = NULL_TREE;
9493                     prefix_attributes = NULL_TREE;
9494                   }
9495
9496                 decl = start_decl (declarator, declspecs, 1,
9497                                    attributes, prefix_attributes);
9498                 decl_type_access_control (decl);
9499                 if (decl)
9500                   {
9501                     /* Look for __unused__ attribute */
9502                     if (TREE_USED (TREE_TYPE (decl)))
9503                       TREE_USED (decl) = 1;
9504                     finish_decl (decl, init, NULL_TREE);
9505                   }
9506                 else
9507                   cp_error ("invalid declarator");
9508                 return 0;
9509               }
9510             innermost_code = TREE_CODE (decl);
9511             if (decl_context == FIELD && ctype == NULL_TREE)
9512               ctype = current_class_type;
9513             if (ctype
9514                 && TREE_OPERAND (decl, 0)
9515                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9516                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9517                          == constructor_name_full (ctype))
9518                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9519                             == constructor_name (ctype)))))
9520               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9521             next = &TREE_OPERAND (decl, 0);
9522             decl = *next;
9523             if (ctype != NULL_TREE
9524                 && decl != NULL_TREE && flags != DTOR_FLAG
9525                 && decl == constructor_name (ctype))
9526               {
9527                 return_type = return_ctor;
9528                 ctor_return_type = ctype;
9529               }
9530             ctype = NULL_TREE;
9531             break;
9532
9533           case TEMPLATE_ID_EXPR:
9534               {
9535                 tree fns = TREE_OPERAND (decl, 0);
9536
9537                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9538                   fns = TREE_OPERAND (fns, 0);
9539
9540                 dname = fns;
9541                 if (TREE_CODE (dname) == COMPONENT_REF)
9542                   dname = TREE_OPERAND (dname, 1);
9543                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9544                   {
9545                     my_friendly_assert (is_overloaded_fn (dname),
9546                                         19990331);
9547                     dname = DECL_NAME (get_first_fn (dname));
9548                   }
9549               }
9550           /* Fall through. */
9551
9552           case IDENTIFIER_NODE:
9553             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9554               dname = decl;
9555
9556             next = 0;
9557
9558             if (is_rid (dname))
9559               {
9560                 cp_error ("declarator-id missing; using reserved word `%D'",
9561                           dname);
9562                 name = IDENTIFIER_POINTER (dname);
9563               }
9564             if (! IDENTIFIER_OPNAME_P (dname)
9565                 /* GNU/Linux headers use '__op'.  Arrgh.  */
9566                 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
9567               name = IDENTIFIER_POINTER (dname);
9568             else
9569               {
9570                 if (IDENTIFIER_TYPENAME_P (dname))
9571                   {
9572                     my_friendly_assert (flags == NO_SPECIAL, 154);
9573                     flags = TYPENAME_FLAG;
9574                     ctor_return_type = TREE_TYPE (dname);
9575                     return_type = return_conversion;
9576                   }
9577                 name = operator_name_string (dname);
9578               }
9579             break;
9580
9581             /* C++ extension */
9582           case SCOPE_REF:
9583             {
9584               /* Perform error checking, and decide on a ctype.  */
9585               tree cname = TREE_OPERAND (decl, 0);
9586               if (cname == NULL_TREE)
9587                 ctype = NULL_TREE;
9588               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9589                 {
9590                   ctype = NULL_TREE;
9591                   in_namespace = TREE_OPERAND (decl, 0);
9592                   TREE_OPERAND (decl, 0) = NULL_TREE;
9593                 }
9594               else if (! is_aggr_type (cname, 1))
9595                 TREE_OPERAND (decl, 0) = NULL_TREE;
9596               /* Must test TREE_OPERAND (decl, 1), in case user gives
9597                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9598               else if (TREE_OPERAND (decl, 1)
9599                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9600                 ctype = cname;
9601               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9602                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9603                 {
9604                   cp_error ("`%T::%D' is not a valid declarator", cname,
9605                             TREE_OPERAND (decl, 1));
9606                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9607                             cname, TREE_OPERAND (decl, 1));
9608                   return void_type_node;
9609                 }
9610               else if (ctype == NULL_TREE)
9611                 ctype = cname;
9612               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9613                 TREE_OPERAND (decl, 0) = ctype;
9614               else
9615                 {
9616                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9617                     {
9618                       cp_error ("type `%T' is not derived from type `%T'",
9619                                 cname, ctype);
9620                       TREE_OPERAND (decl, 0) = NULL_TREE;
9621                     }
9622                   else
9623                     ctype = cname;
9624                 }
9625
9626               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9627                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9628                        == constructor_name_full (ctype))
9629                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9630                           == constructor_name (ctype))))
9631                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9632               next = &TREE_OPERAND (decl, 1);
9633               decl = *next;
9634               if (ctype)
9635                 {
9636                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9637                       && constructor_name (ctype) == decl)
9638                     {
9639                       return_type = return_ctor;
9640                       ctor_return_type = ctype;
9641                     }
9642                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9643                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9644                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9645                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9646                     {
9647                       return_type = return_dtor;
9648                       ctor_return_type = ctype;
9649                       flags = DTOR_FLAG;
9650                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9651                       next = &TREE_OPERAND (decl, 0);
9652                     }
9653                 }
9654             }
9655             break;
9656
9657           case ERROR_MARK:
9658             next = 0;
9659             break;
9660
9661           case TYPE_DECL:
9662             /* Parse error puts this typespec where
9663                a declarator should go.  */
9664             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9665             if (TREE_TYPE (decl) == current_class_type)
9666               cp_error ("  perhaps you want `%T' for a constructor",
9667                         current_class_name);
9668             dname = DECL_NAME (decl);
9669             name = IDENTIFIER_POINTER (dname);
9670
9671             /* Avoid giving two errors for this.  */
9672             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9673
9674             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9675             *next = dname;
9676             next = 0;
9677             break;
9678
9679           default:
9680             cp_compiler_error ("`%D' as declarator", decl);
9681             return 0; /* We used to do a 155 abort here.  */
9682           }
9683       }
9684   }
9685
9686   /* A function definition's declarator must have the form of
9687      a function declarator.  */
9688
9689   if (funcdef_flag && innermost_code != CALL_EXPR)
9690     return 0;
9691
9692   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9693       && innermost_code != CALL_EXPR
9694       && ! (ctype && declspecs == NULL_TREE))
9695     {
9696       cp_error ("declaration of `%D' as non-function", dname);
9697       return void_type_node;
9698     }
9699
9700   /* Anything declared one level down from the top level
9701      must be one of the parameters of a function
9702      (because the body is at least two levels down).  */
9703
9704   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9705      by not allowing C++ class definitions to specify their parameters
9706      with xdecls (must be spec.d in the parmlist).
9707
9708      Since we now wait to push a class scope until we are sure that
9709      we are in a legitimate method context, we must set oldcname
9710      explicitly (since current_class_name is not yet alive).
9711
9712      We also want to avoid calling this a PARM if it is in a namespace.  */
9713
9714   if (decl_context == NORMAL && !toplevel_bindings_p ())
9715     {
9716       struct binding_level *b = current_binding_level;
9717       current_binding_level = b->level_chain;
9718       if (current_binding_level != 0 && toplevel_bindings_p ())
9719         decl_context = PARM;
9720       current_binding_level = b;
9721     }
9722
9723   if (name == NULL)
9724     name = decl_context == PARM ? "parameter" : "type name";
9725
9726   /* Look through the decl specs and record which ones appear.
9727      Some typespecs are defined as built-in typenames.
9728      Others, the ones that are modifiers of other types,
9729      are represented by bits in SPECBITS: set the bits for
9730      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9731
9732      If there is a typedef name or a type, store the type in TYPE.
9733      This includes builtin typedefs such as `int'.
9734
9735      Set EXPLICIT_INT if the type is `int' or `char' and did not
9736      come from a user typedef.
9737
9738      Set LONGLONG if `long' is mentioned twice.
9739
9740      For C++, constructors and destructors have their own fast treatment.  */
9741
9742   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9743     {
9744       register int i;
9745       register tree id;
9746
9747       /* Certain parse errors slip through.  For example,
9748          `int class;' is not caught by the parser. Try
9749          weakly to recover here.  */
9750       if (TREE_CODE (spec) != TREE_LIST)
9751         return 0;
9752
9753       id = TREE_VALUE (spec);
9754
9755       if (TREE_CODE (id) == IDENTIFIER_NODE)
9756         {
9757           if (id == ridpointers[(int) RID_INT]
9758               || id == ridpointers[(int) RID_CHAR]
9759               || id == ridpointers[(int) RID_BOOL]
9760               || id == ridpointers[(int) RID_WCHAR])
9761             {
9762               if (type)
9763                 {
9764                   if (id == ridpointers[(int) RID_BOOL])
9765                     error ("`bool' is now a keyword");
9766                   else
9767                     cp_error ("extraneous `%T' ignored", id);
9768                 }
9769               else
9770                 {
9771                   if (id == ridpointers[(int) RID_INT])
9772                     explicit_int = 1;
9773                   else if (id == ridpointers[(int) RID_CHAR])
9774                     explicit_char = 1;
9775                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9776                 }
9777               goto found;
9778             }
9779           /* C++ aggregate types.  */
9780           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9781             {
9782               if (type)
9783                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9784               else
9785                 type = IDENTIFIER_TYPE_VALUE (id);
9786               goto found;
9787             }
9788
9789           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9790             {
9791               if (ridpointers[i] == id)
9792                 {
9793                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9794                     {
9795                       if (pedantic && ! in_system_header && warn_long_long)
9796                         pedwarn ("ISO C++ does not support `long long'");
9797                       if (longlong)
9798                         error ("`long long long' is too long for GCC");
9799                       else
9800                         longlong = 1;
9801                     }
9802                   else if (RIDBIT_SETP (i, specbits))
9803                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9804                   RIDBIT_SET (i, specbits);
9805                   goto found;
9806                 }
9807             }
9808         }
9809       /* C++ aggregate types.  */
9810       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9811         {
9812           if (type)
9813             cp_error ("multiple declarations `%T' and `%T'", type,
9814                       TREE_TYPE (id));
9815           else
9816             {
9817               type = TREE_TYPE (id);
9818               TREE_VALUE (spec) = type;
9819             }
9820           goto found;
9821         }
9822       if (type)
9823         error ("two or more data types in declaration of `%s'", name);
9824       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9825         {
9826           register tree t = lookup_name (id, 1);
9827           if (!t || TREE_CODE (t) != TYPE_DECL)
9828             error ("`%s' fails to be a typedef or built in type",
9829                    IDENTIFIER_POINTER (id));
9830           else
9831             {
9832               type = TREE_TYPE (t);
9833 #if 0
9834               /* See the code below that used this.  */
9835               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9836 #endif
9837               typedef_decl = t;
9838             }
9839         }
9840       else if (id != error_mark_node)
9841         /* Can't change CLASS nodes into RECORD nodes here!  */
9842         type = id;
9843
9844     found: ;
9845     }
9846
9847   typedef_type = type;
9848
9849   /* No type at all: default to `int', and set DEFAULTED_INT
9850      because it was not a user-defined typedef.  */
9851
9852   if (type == NULL_TREE
9853       && (RIDBIT_SETP (RID_SIGNED, specbits)
9854           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9855           || RIDBIT_SETP (RID_LONG, specbits)
9856           || RIDBIT_SETP (RID_SHORT, specbits)))
9857     {
9858       /* These imply 'int'.  */
9859       type = integer_type_node;
9860       defaulted_int = 1;
9861     }
9862
9863   if (type == NULL_TREE)
9864     {
9865       explicit_int = -1;
9866       if (return_type == return_dtor)
9867         type = void_type_node;
9868       else if (return_type == return_ctor)
9869         type = build_pointer_type (ctor_return_type);
9870       else if (return_type == return_conversion)
9871         type = ctor_return_type;
9872       else
9873         {
9874           /* We handle `main' specially here, because 'main () { }' is so
9875              common.  With no options, it is allowed.  With -Wreturn-type,
9876              it is a warning.  It is only an error with -pedantic-errors.  */
9877           int is_main = (funcdef_flag
9878                          && MAIN_NAME_P (dname)
9879                          && ctype == NULL_TREE
9880                          && in_namespace == NULL_TREE
9881                          && current_namespace == global_namespace);
9882
9883           if (in_system_header || flag_ms_extensions)
9884             /* Allow it, sigh.  */;
9885           else if (pedantic || ! is_main)
9886             cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
9887                         name);
9888           else if (warn_return_type)
9889             cp_warning ("ISO C++ forbids declaration of `%s' with no type",
9890                         name);
9891
9892           type = integer_type_node;
9893         }
9894     }
9895   else if (return_type == return_dtor)
9896     {
9897       error ("return type specification for destructor invalid");
9898       type = void_type_node;
9899     }
9900   else if (return_type == return_ctor)
9901     {
9902       error ("return type specification for constructor invalid");
9903       type = build_pointer_type (ctor_return_type);
9904     }
9905   else if (return_type == return_conversion)
9906     {
9907       if (!same_type_p (type, ctor_return_type))
9908         cp_error ("operator `%T' declared to return `%T'",
9909                   ctor_return_type, type);
9910       else
9911         cp_pedwarn ("return type specified for `operator %T'",
9912                     ctor_return_type);
9913
9914       type = ctor_return_type;
9915     }
9916
9917   ctype = NULL_TREE;
9918
9919   /* Now process the modifiers that were specified
9920      and check for invalid combinations.  */
9921
9922   /* Long double is a special combination.  */
9923
9924   if (RIDBIT_SETP (RID_LONG, specbits)
9925       && TYPE_MAIN_VARIANT (type) == double_type_node)
9926     {
9927       RIDBIT_RESET (RID_LONG, specbits);
9928       type = build_qualified_type (long_double_type_node,
9929                                    CP_TYPE_QUALS (type));
9930     }
9931
9932   /* Check all other uses of type modifiers.  */
9933
9934   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9935       || RIDBIT_SETP (RID_SIGNED, specbits)
9936       || RIDBIT_SETP (RID_LONG, specbits)
9937       || RIDBIT_SETP (RID_SHORT, specbits))
9938     {
9939       int ok = 0;
9940
9941       if (TREE_CODE (type) == REAL_TYPE)
9942         error ("short, signed or unsigned invalid for `%s'", name);
9943       else if (TREE_CODE (type) != INTEGER_TYPE)
9944         error ("long, short, signed or unsigned invalid for `%s'", name);
9945       else if (RIDBIT_SETP (RID_LONG, specbits)
9946                && RIDBIT_SETP (RID_SHORT, specbits))
9947         error ("long and short specified together for `%s'", name);
9948       else if ((RIDBIT_SETP (RID_LONG, specbits)
9949                 || RIDBIT_SETP (RID_SHORT, specbits))
9950                && explicit_char)
9951         error ("long or short specified with char for `%s'", name);
9952       else if ((RIDBIT_SETP (RID_LONG, specbits)
9953                 || RIDBIT_SETP (RID_SHORT, specbits))
9954                && TREE_CODE (type) == REAL_TYPE)
9955         error ("long or short specified with floating type for `%s'", name);
9956       else if (RIDBIT_SETP (RID_SIGNED, specbits)
9957                && RIDBIT_SETP (RID_UNSIGNED, specbits))
9958         error ("signed and unsigned given together for `%s'", name);
9959       else
9960         {
9961           ok = 1;
9962           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
9963             {
9964               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9965                        name);
9966               if (flag_pedantic_errors)
9967                 ok = 0;
9968             }
9969         }
9970
9971       /* Discard the type modifiers if they are invalid.  */
9972       if (! ok)
9973         {
9974           RIDBIT_RESET (RID_UNSIGNED, specbits);
9975           RIDBIT_RESET (RID_SIGNED, specbits);
9976           RIDBIT_RESET (RID_LONG, specbits);
9977           RIDBIT_RESET (RID_SHORT, specbits);
9978           longlong = 0;
9979         }
9980     }
9981
9982   if (RIDBIT_SETP (RID_COMPLEX, specbits)
9983       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9984     {
9985       error ("complex invalid for `%s'", name);
9986       RIDBIT_RESET (RID_COMPLEX, specbits);
9987     }
9988
9989   /* Decide whether an integer type is signed or not.
9990      Optionally treat bitfields as signed by default.  */
9991   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9992       /* [class.bit]
9993
9994          It is implementation-defined whether a plain (neither
9995          explicitly signed or unsigned) char, short, int, or long
9996          bit-field is signed or unsigned.
9997
9998          Naturally, we extend this to long long as well.  Note that
9999          this does not include wchar_t.  */
10000       || (bitfield && !flag_signed_bitfields
10001           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10002           /* A typedef for plain `int' without `signed' can be
10003              controlled just like plain `int', but a typedef for
10004              `signed int' cannot be so controlled.  */
10005           && !(typedef_decl
10006                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10007           && (TREE_CODE (type) == INTEGER_TYPE
10008               || TREE_CODE (type) == CHAR_TYPE)
10009           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10010     {
10011       if (longlong)
10012         type = long_long_unsigned_type_node;
10013       else if (RIDBIT_SETP (RID_LONG, specbits))
10014         type = long_unsigned_type_node;
10015       else if (RIDBIT_SETP (RID_SHORT, specbits))
10016         type = short_unsigned_type_node;
10017       else if (type == char_type_node)
10018         type = unsigned_char_type_node;
10019       else if (typedef_decl)
10020         type = unsigned_type (type);
10021       else
10022         type = unsigned_type_node;
10023     }
10024   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10025            && type == char_type_node)
10026     type = signed_char_type_node;
10027   else if (longlong)
10028     type = long_long_integer_type_node;
10029   else if (RIDBIT_SETP (RID_LONG, specbits))
10030     type = long_integer_type_node;
10031   else if (RIDBIT_SETP (RID_SHORT, specbits))
10032     type = short_integer_type_node;
10033
10034   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10035     {
10036       /* If we just have "complex", it is equivalent to
10037          "complex double", but if any modifiers at all are specified it is
10038          the complex form of TYPE.  E.g, "complex short" is
10039          "complex short int".  */
10040
10041       if (defaulted_int && ! longlong
10042           && ! (RIDBIT_SETP (RID_LONG, specbits)
10043                 || RIDBIT_SETP (RID_SHORT, specbits)
10044                 || RIDBIT_SETP (RID_SIGNED, specbits)
10045                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10046         type = complex_double_type_node;
10047       else if (type == integer_type_node)
10048         type = complex_integer_type_node;
10049       else if (type == float_type_node)
10050         type = complex_float_type_node;
10051       else if (type == double_type_node)
10052         type = complex_double_type_node;
10053       else if (type == long_double_type_node)
10054         type = complex_long_double_type_node;
10055       else
10056         type = build_complex_type (type);
10057     }
10058
10059   if (return_type == return_conversion
10060       && (RIDBIT_SETP (RID_CONST, specbits)
10061           || RIDBIT_SETP (RID_VOLATILE, specbits)
10062           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10063     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10064               ctor_return_type);
10065
10066   /* Set CONSTP if this declaration is `const', whether by
10067      explicit specification or via a typedef.
10068      Likewise for VOLATILEP.  */
10069
10070   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10071   restrictp =
10072     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10073   volatilep =
10074     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10075   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10076                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10077                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10078   type = cp_build_qualified_type (type, type_quals);
10079   staticp = 0;
10080   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10081   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10082   RIDBIT_RESET (RID_VIRTUAL, specbits);
10083   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10084   RIDBIT_RESET (RID_EXPLICIT, specbits);
10085
10086   if (RIDBIT_SETP (RID_STATIC, specbits))
10087     staticp = 1 + (decl_context == FIELD);
10088
10089   if (virtualp && staticp == 2)
10090     {
10091       cp_error ("member `%D' cannot be declared both virtual and static",
10092                 dname);
10093       staticp = 0;
10094     }
10095   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10096   RIDBIT_RESET (RID_FRIEND, specbits);
10097
10098   /* Warn if two storage classes are given. Default to `auto'.  */
10099
10100   if (RIDBIT_ANY_SET (specbits))
10101     {
10102       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10103       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10104       if (decl_context == PARM && nclasses > 0)
10105         error ("storage class specifiers invalid in parameter declarations");
10106       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10107         {
10108           if (decl_context == PARM)
10109             error ("typedef declaration invalid in parameter declaration");
10110           nclasses++;
10111         }
10112       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10113       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10114     }
10115
10116   /* Give error if `virtual' is used outside of class declaration.  */
10117   if (virtualp
10118       && (current_class_name == NULL_TREE || decl_context != FIELD))
10119     {
10120       error ("virtual outside class declaration");
10121       virtualp = 0;
10122     }
10123
10124   /* Static anonymous unions are dealt with here.  */
10125   if (staticp && decl_context == TYPENAME
10126       && TREE_CODE (declspecs) == TREE_LIST
10127       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10128     decl_context = FIELD;
10129
10130   /* Warn about storage classes that are invalid for certain
10131      kinds of declarations (parameters, typenames, etc.).  */
10132
10133   if (nclasses > 1)
10134     error ("multiple storage classes in declaration of `%s'", name);
10135   else if (decl_context != NORMAL && nclasses > 0)
10136     {
10137       if ((decl_context == PARM || decl_context == CATCHPARM)
10138           && (RIDBIT_SETP (RID_REGISTER, specbits)
10139               || RIDBIT_SETP (RID_AUTO, specbits)))
10140         ;
10141       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10142         ;
10143       else if (decl_context == FIELD
10144                /* C++ allows static class elements  */
10145                && RIDBIT_SETP (RID_STATIC, specbits))
10146         /* C++ also allows inlines and signed and unsigned elements,
10147            but in those cases we don't come in here.  */
10148         ;
10149       else
10150         {
10151           if (decl_context == FIELD)
10152             {
10153               tree tmp = NULL_TREE;
10154               register int op = 0;
10155
10156               if (declarator)
10157                 {
10158                   /* Avoid trying to get an operand off an identifier node.  */
10159                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10160                     tmp = declarator;
10161                   else
10162                     tmp = TREE_OPERAND (declarator, 0);
10163                   op = IDENTIFIER_OPNAME_P (tmp);
10164                 }
10165               error ("storage class specified for %s `%s'",
10166                      op ? "member operator" : "field",
10167                      op ? operator_name_string (tmp) : name);
10168             }
10169           else
10170             {
10171               if (decl_context == PARM || decl_context == CATCHPARM)
10172                 error ("storage class specified for parameter `%s'", name);
10173               else
10174                 error ("storage class specified for typename");
10175             }
10176           RIDBIT_RESET (RID_REGISTER, specbits);
10177           RIDBIT_RESET (RID_AUTO, specbits);
10178           RIDBIT_RESET (RID_EXTERN, specbits);
10179         }
10180     }
10181   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10182     {
10183       if (toplevel_bindings_p ())
10184         {
10185           /* It's common practice (and completely valid) to have a const
10186              be initialized and declared extern.  */
10187           if (!(type_quals & TYPE_QUAL_CONST))
10188             warning ("`%s' initialized and declared `extern'", name);
10189         }
10190       else
10191         error ("`%s' has both `extern' and initializer", name);
10192     }
10193   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10194            && ! toplevel_bindings_p ())
10195     error ("nested function `%s' declared `extern'", name);
10196   else if (toplevel_bindings_p ())
10197     {
10198       if (RIDBIT_SETP (RID_AUTO, specbits))
10199         error ("top-level declaration of `%s' specifies `auto'", name);
10200     }
10201
10202   if (nclasses > 0 && friendp)
10203     error ("storage class specifiers invalid in friend function declarations");
10204
10205   /* Now figure out the structure of the declarator proper.
10206      Descend through it, creating more complex types, until we reach
10207      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10208
10209   inner_attrs = NULL_TREE;
10210   ignore_attrs = 0;
10211
10212   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10213          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10214     {
10215       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10216          an INDIRECT_REF (for *...),
10217          a CALL_EXPR (for ...(...)),
10218          an identifier (for the name being declared)
10219          or a null pointer (for the place in an absolute declarator
10220          where the name was omitted).
10221          For the last two cases, we have just exited the loop.
10222
10223          For C++ it could also be
10224          a SCOPE_REF (for class :: ...).  In this case, we have converted
10225          sensible names to types, and those are the values we use to
10226          qualify the member name.
10227          an ADDR_EXPR (for &...),
10228          a BIT_NOT_EXPR (for destructors)
10229
10230          At this point, TYPE is the type of elements of an array,
10231          or for a function to return, or for a pointer to point to.
10232          After this sequence of ifs, TYPE is the type of the
10233          array or function or pointer, and DECLARATOR has had its
10234          outermost layer removed.  */
10235
10236       if (type == error_mark_node)
10237         {
10238           if (TREE_CODE (declarator) == SCOPE_REF)
10239             declarator = TREE_OPERAND (declarator, 1);
10240           else
10241             declarator = TREE_OPERAND (declarator, 0);
10242           continue;
10243         }
10244       if (quals != NULL_TREE
10245           && (declarator == NULL_TREE
10246               || TREE_CODE (declarator) != SCOPE_REF))
10247         {
10248           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10249             ctype = TYPE_METHOD_BASETYPE (type);
10250           if (ctype != NULL_TREE)
10251             {
10252               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10253               grok_method_quals (ctype, dummy, quals);
10254               type = TREE_TYPE (dummy);
10255               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10256               quals = NULL_TREE;
10257             }
10258         }
10259
10260       /* See the comment for the TREE_LIST case, below.  */
10261       if (ignore_attrs)
10262         ignore_attrs = 0;
10263       else if (inner_attrs)
10264         {
10265           decl_attributes (type, inner_attrs, NULL_TREE);
10266           inner_attrs = NULL_TREE;
10267         }
10268
10269       switch (TREE_CODE (declarator))
10270         {
10271         case TREE_LIST:
10272           {
10273             /* We encode a declarator with embedded attributes using
10274                a TREE_LIST.  The attributes apply to the declarator
10275                directly inside them, so we have to skip an iteration
10276                before applying them to the type.  If the declarator just
10277                inside is the declarator-id, we apply the attrs to the
10278                decl itself.  */
10279             inner_attrs = TREE_PURPOSE (declarator);
10280             ignore_attrs = 1;
10281             declarator = TREE_VALUE (declarator);
10282           }
10283           break;
10284
10285         case ARRAY_REF:
10286           {
10287             register tree size;
10288
10289             size = TREE_OPERAND (declarator, 1);
10290
10291             /* VC++ spells a zero-sized array with [].  */
10292             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10293                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10294               size = integer_zero_node;
10295
10296             declarator = TREE_OPERAND (declarator, 0);
10297
10298             type = create_array_type_for_decl (dname, type, size);
10299             ctype = NULL_TREE;
10300           }
10301           break;
10302
10303         case CALL_EXPR:
10304           {
10305             tree arg_types;
10306             int funcdecl_p;
10307             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10308             tree inner_decl = TREE_OPERAND (declarator, 0);
10309
10310             /* Declaring a function type.
10311                Make sure we have a valid type for the function to return.  */
10312
10313             /* We now know that the TYPE_QUALS don't apply to the
10314                decl, but to its return type.  */
10315             type_quals = TYPE_UNQUALIFIED;
10316
10317             /* Warn about some types functions can't return.  */
10318
10319             if (TREE_CODE (type) == FUNCTION_TYPE)
10320               {
10321                 error ("`%s' declared as function returning a function", name);
10322                 type = integer_type_node;
10323               }
10324             if (TREE_CODE (type) == ARRAY_TYPE)
10325               {
10326                 error ("`%s' declared as function returning an array", name);
10327                 type = integer_type_node;
10328               }
10329
10330             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10331               inner_decl = TREE_OPERAND (inner_decl, 1);
10332
10333             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10334               inner_decl = dname;
10335
10336             /* Pick up type qualifiers which should be applied to `this'.  */
10337             quals = CALL_DECLARATOR_QUALS (declarator);
10338
10339             /* Pick up the exception specifications.  */
10340             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10341
10342             /* Say it's a definition only for the CALL_EXPR
10343                closest to the identifier.  */
10344             funcdecl_p
10345               = inner_decl
10346               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10347                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10348                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10349
10350             if (ctype == NULL_TREE
10351                 && decl_context == FIELD
10352                 && funcdecl_p
10353                 && (friendp == 0 || dname == current_class_name))
10354               ctype = current_class_type;
10355
10356             if (ctype && return_type == return_conversion)
10357               TYPE_HAS_CONVERSION (ctype) = 1;
10358             if (ctype && constructor_name (ctype) == dname)
10359               {
10360                 /* We are within a class's scope. If our declarator name
10361                    is the same as the class name, and we are defining
10362                    a function, then it is a constructor/destructor, and
10363                    therefore returns a void type.  */
10364
10365                 if (flags == DTOR_FLAG)
10366                   {
10367                     /* ISO C++ 12.4/2.  A destructor may not be
10368                        declared const or volatile.  A destructor may
10369                        not be static.  */
10370                     if (staticp == 2)
10371                       error ("destructor cannot be static member function");
10372                     if (quals)
10373                       {
10374                         cp_error ("destructors may not be `%s'",
10375                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10376                         quals = NULL_TREE;
10377                       }
10378                     if (decl_context == FIELD)
10379                       {
10380                         if (! member_function_or_else (ctype,
10381                                                        current_class_type,
10382                                                        flags))
10383                           return void_type_node;
10384                       }
10385                   }
10386                 else            /* It's a constructor.  */
10387                   {
10388                     if (explicitp == 1)
10389                       explicitp = 2;
10390                     /* ISO C++ 12.1.  A constructor may not be
10391                        declared const or volatile.  A constructor may
10392                        not be virtual.  A constructor may not be
10393                        static.  */
10394                     if (staticp == 2)
10395                       error ("constructor cannot be static member function");
10396                     if (virtualp)
10397                       {
10398                         pedwarn ("constructors cannot be declared virtual");
10399                         virtualp = 0;
10400                       }
10401                     if (quals)
10402                       {
10403                         cp_error ("constructors may not be `%s'",
10404                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10405                         quals = NULL_TREE;
10406                       }
10407                     {
10408                       RID_BIT_TYPE tmp_bits;
10409                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10410                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10411                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10412                       if (RIDBIT_ANY_SET (tmp_bits))
10413                         error ("return value type specifier for constructor ignored");
10414                     }
10415                     type = build_pointer_type (ctype);
10416                     if (decl_context == FIELD)
10417                       {
10418                         if (! member_function_or_else (ctype,
10419                                                        current_class_type,
10420                                                        flags))
10421                           return void_type_node;
10422                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10423                         if (return_type != return_ctor)
10424                           return NULL_TREE;
10425                       }
10426                   }
10427                 if (decl_context == FIELD)
10428                   staticp = 0;
10429               }
10430             else if (friendp)
10431               {
10432                 if (initialized)
10433                   error ("can't initialize friend function `%s'", name);
10434                 if (virtualp)
10435                   {
10436                     /* Cannot be both friend and virtual.  */
10437                     error ("virtual functions cannot be friends");
10438                     RIDBIT_RESET (RID_FRIEND, specbits);
10439                     friendp = 0;
10440                   }
10441                 if (decl_context == NORMAL)
10442                   error ("friend declaration not in class definition");
10443                 if (current_function_decl && funcdef_flag)
10444                   cp_error ("can't define friend function `%s' in a local class definition",
10445                             name);
10446               }
10447
10448             /* Construct the function type and go to the next
10449                inner layer of declarator.  */
10450
10451             declarator = TREE_OPERAND (declarator, 0);
10452
10453             /* FIXME: This is where default args should be fully
10454                processed.  */
10455
10456             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10457
10458             if (declarator && flags == DTOR_FLAG)
10459               {
10460                 /* A destructor declared in the body of a class will
10461                    be represented as a BIT_NOT_EXPR.  But, we just
10462                    want the underlying IDENTIFIER.  */
10463                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10464                   declarator = TREE_OPERAND (declarator, 0);
10465
10466                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10467                   arg_types = void_list_node;
10468                 else if (arg_types == NULL_TREE
10469                          || arg_types != void_list_node)
10470                   {
10471                     cp_error ("destructors may not have parameters");
10472                     arg_types = void_list_node;
10473                     last_function_parms = NULL_TREE;
10474                   }
10475               }
10476
10477             /* ANSI says that `const int foo ();'
10478                does not make the function foo const.  */
10479             type = build_function_type (type, arg_types);
10480
10481             {
10482               tree t;
10483               for (t = arg_types; t; t = TREE_CHAIN (t))
10484                 if (TREE_PURPOSE (t)
10485                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10486                   {
10487                     add_defarg_fn (type);
10488                     break;
10489                   }
10490             }
10491           }
10492           break;
10493
10494         case ADDR_EXPR:
10495         case INDIRECT_REF:
10496           /* Filter out pointers-to-references and references-to-references.
10497              We can get these if a TYPE_DECL is used.  */
10498
10499           if (TREE_CODE (type) == REFERENCE_TYPE)
10500             {
10501               error ("cannot declare %s to references",
10502                      TREE_CODE (declarator) == ADDR_EXPR
10503                      ? "references" : "pointers");
10504               declarator = TREE_OPERAND (declarator, 0);
10505               continue;
10506             }
10507
10508           if (TREE_CODE (type) == OFFSET_TYPE
10509               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10510                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10511             {
10512               cp_error ("cannot declare pointer to `%#T' member",
10513                         TREE_TYPE (type));
10514               type = TREE_TYPE (type);
10515             }
10516
10517           /* Merge any constancy or volatility into the target type
10518              for the pointer.  */
10519
10520           /* We now know that the TYPE_QUALS don't apply to the decl,
10521              but to the target of the pointer.  */
10522           type_quals = TYPE_UNQUALIFIED;
10523
10524           if (TREE_CODE (declarator) == ADDR_EXPR)
10525             {
10526               if (TREE_CODE (type) == VOID_TYPE)
10527                 error ("invalid type: `void &'");
10528               else
10529                 type = build_reference_type (type);
10530             }
10531           else if (TREE_CODE (type) == METHOD_TYPE)
10532             type = build_ptrmemfunc_type (build_pointer_type (type));
10533           else
10534             type = build_pointer_type (type);
10535
10536           /* Process a list of type modifier keywords (such as
10537              const or volatile) that were given inside the `*' or `&'.  */
10538
10539           if (TREE_TYPE (declarator))
10540             {
10541               register tree typemodlist;
10542               int erred = 0;
10543
10544               constp = 0;
10545               volatilep = 0;
10546               restrictp = 0;
10547               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10548                    typemodlist = TREE_CHAIN (typemodlist))
10549                 {
10550                   tree qualifier = TREE_VALUE (typemodlist);
10551
10552                   if (qualifier == ridpointers[(int) RID_CONST])
10553                     constp++;
10554                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10555                     volatilep++;
10556                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10557                     restrictp++;
10558                   else if (!erred)
10559                     {
10560                       erred = 1;
10561                       error ("invalid type modifier within pointer declarator");
10562                     }
10563                 }
10564               if (constp > 1)
10565                 pedwarn ("duplicate `const'");
10566               if (volatilep > 1)
10567                 pedwarn ("duplicate `volatile'");
10568               if (restrictp > 1)
10569                 pedwarn ("duplicate `restrict'");
10570
10571               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10572                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10573                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10574               if (TREE_CODE (declarator) == ADDR_EXPR
10575                   && (constp || volatilep))
10576                 {
10577                   if (constp)
10578                     pedwarn ("discarding `const' applied to a reference");
10579                   if (volatilep)
10580                     pedwarn ("discarding `volatile' applied to a reference");
10581                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10582                 }
10583               type = cp_build_qualified_type (type, type_quals);
10584             }
10585           declarator = TREE_OPERAND (declarator, 0);
10586           ctype = NULL_TREE;
10587           break;
10588
10589         case SCOPE_REF:
10590           {
10591             /* We have converted type names to NULL_TREE if the
10592                name was bogus, or to a _TYPE node, if not.
10593
10594                The variable CTYPE holds the type we will ultimately
10595                resolve to.  The code here just needs to build
10596                up appropriate member types.  */
10597             tree sname = TREE_OPERAND (declarator, 1);
10598             tree t;
10599
10600             /* Destructors can have their visibilities changed as well.  */
10601             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10602               sname = TREE_OPERAND (sname, 0);
10603
10604             if (TREE_COMPLEXITY (declarator) == 0)
10605               /* This needs to be here, in case we are called
10606                  multiple times.  */ ;
10607             else if (TREE_COMPLEXITY (declarator) == -1)
10608               /* Namespace member. */
10609               pop_decl_namespace ();
10610             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10611               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10612             else if (! IS_AGGR_TYPE_CODE
10613                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10614               ;
10615             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10616               {
10617                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10618                    that refer to ctype.  They couldn't be resolved earlier
10619                    because we hadn't pushed into the class yet.
10620                    Example: resolve 'B<T>::type' in
10621                    'B<typename B<T>::type> B<T>::f () { }'.  */
10622                 if (current_template_parms
10623                     && uses_template_parms (type)
10624                     && uses_template_parms (current_class_type))
10625                   {
10626                     tree args = current_template_args ();
10627                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10628                   }
10629
10630                 /* This pop_nested_class corresponds to the
10631                    push_nested_class used to push into class scope for
10632                    parsing the argument list of a function decl, in
10633                    qualified_id.  */
10634                 pop_nested_class ();
10635                 TREE_COMPLEXITY (declarator) = current_class_depth;
10636               }
10637             else
10638               my_friendly_abort (16);
10639
10640             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10641               {
10642                 /* We had a reference to a global decl, or
10643                    perhaps we were given a non-aggregate typedef,
10644                    in which case we cleared this out, and should just
10645                    keep going as though it wasn't there.  */
10646                 declarator = sname;
10647                 continue;
10648               }
10649             ctype = TREE_OPERAND (declarator, 0);
10650
10651             t = ctype;
10652             while (t != NULL_TREE && CLASS_TYPE_P (t))
10653               {
10654                 if (CLASSTYPE_TEMPLATE_INFO (t) &&
10655                     !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
10656                   template_count += 1;
10657                 t = TYPE_MAIN_DECL (t);
10658                 if (DECL_LANG_SPECIFIC (t))
10659                   t = DECL_CONTEXT (t);
10660                 else
10661                   t = NULL_TREE;
10662               }
10663
10664             if (sname == NULL_TREE)
10665               goto done_scoping;
10666
10667             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10668               {
10669                 /* This is the `standard' use of the scoping operator:
10670                    basetype :: member .  */
10671
10672                 if (ctype == current_class_type)
10673                   {
10674                     /* class A {
10675                          void A::f ();
10676                        };
10677
10678                        Is this ill-formed?  */
10679
10680                     if (pedantic)
10681                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10682                                   ctype, name);
10683                   }
10684                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10685                   {
10686                     if (current_class_type == NULL_TREE
10687                         || friendp)
10688                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10689                                                       TYPE_ARG_TYPES (type));
10690                     else
10691                       {
10692                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10693                                   ctype, name, current_class_type);
10694                         return void_type_node;
10695                       }
10696                   }
10697                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10698                          || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
10699                   {
10700                     /* Have to move this code elsewhere in this function.
10701                        this code is used for i.e., typedef int A::M; M *pm;
10702
10703                        It is?  How? jason 10/2/94 */
10704
10705                     if (current_class_type)
10706                       {
10707                         cp_error ("cannot declare member `%T::%s' within `%T'",
10708                                   ctype, name, current_class_type);
10709                         return void_type_node;
10710                       }
10711                     type = build_offset_type (ctype, type);
10712                   }
10713                 else if (uses_template_parms (ctype))
10714                   {
10715                     if (TREE_CODE (type) == FUNCTION_TYPE)
10716                       type
10717                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10718                                                    TYPE_ARG_TYPES (type));
10719                   }
10720                 else
10721                   {
10722                     cp_error ("structure `%T' not yet defined", ctype);
10723                     return error_mark_node;
10724                   }
10725
10726                 declarator = sname;
10727               }
10728             else if (TREE_CODE (sname) == SCOPE_REF)
10729               my_friendly_abort (17);
10730             else
10731               {
10732               done_scoping:
10733                 declarator = TREE_OPERAND (declarator, 1);
10734                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10735                   /* In this case, we will deal with it later.  */
10736                   ;
10737                 else
10738                   {
10739                     if (TREE_CODE (type) == FUNCTION_TYPE)
10740                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10741                                                       TYPE_ARG_TYPES (type));
10742                     else
10743                       type = build_offset_type (ctype, type);
10744                   }
10745               }
10746           }
10747           break;
10748
10749         case BIT_NOT_EXPR:
10750           declarator = TREE_OPERAND (declarator, 0);
10751           break;
10752
10753         case RECORD_TYPE:
10754         case UNION_TYPE:
10755         case ENUMERAL_TYPE:
10756           declarator = NULL_TREE;
10757           break;
10758
10759         case ERROR_MARK:
10760           declarator = NULL_TREE;
10761           break;
10762
10763         default:
10764           my_friendly_abort (158);
10765         }
10766     }
10767
10768   /* See the comment for the TREE_LIST case, above.  */
10769   if (inner_attrs)
10770     {
10771       if (! ignore_attrs)
10772         decl_attributes (type, inner_attrs, NULL_TREE);
10773       else if (attrlist)
10774         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10775       else
10776         attrlist = build_decl_list (NULL_TREE, inner_attrs);
10777     }
10778
10779   /* Now TYPE has the actual type.  */
10780
10781   if (explicitp == 1 || (explicitp && friendp))
10782     {
10783       /* [dcl.fct.spec] The explicit specifier shall only be used in
10784          declarations of constructors within a class definition.  */
10785       error ("only declarations of constructors can be `explicit'");
10786       explicitp = 0;
10787     }
10788
10789   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10790     {
10791       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10792         {
10793           error ("non-member `%s' cannot be declared `mutable'", name);
10794           RIDBIT_RESET (RID_MUTABLE, specbits);
10795         }
10796       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10797         {
10798           error ("non-object member `%s' cannot be declared `mutable'", name);
10799           RIDBIT_RESET (RID_MUTABLE, specbits);
10800         }
10801       else if (TREE_CODE (type) == FUNCTION_TYPE
10802                || TREE_CODE (type) == METHOD_TYPE)
10803         {
10804           error ("function `%s' cannot be declared `mutable'", name);
10805           RIDBIT_RESET (RID_MUTABLE, specbits);
10806         }
10807       else if (staticp)
10808         {
10809           error ("static `%s' cannot be declared `mutable'", name);
10810           RIDBIT_RESET (RID_MUTABLE, specbits);
10811         }
10812       else if (type_quals & TYPE_QUAL_CONST)
10813         {
10814           error ("const `%s' cannot be declared `mutable'", name);
10815           RIDBIT_RESET (RID_MUTABLE, specbits);
10816         }
10817     }
10818
10819   if (declarator == NULL_TREE
10820       || TREE_CODE (declarator) == IDENTIFIER_NODE
10821       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10822           && (TREE_CODE (type) == FUNCTION_TYPE
10823               || TREE_CODE (type) == METHOD_TYPE)))
10824     /* OK */;
10825   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10826     {
10827       cp_error ("template-id `%D' used as a declarator", declarator);
10828       declarator = dname;
10829     }
10830   else
10831     /* Unexpected declarator format.  */
10832     my_friendly_abort (990210);
10833
10834   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10835
10836   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10837     {
10838       tree decl;
10839
10840       /* Note that the grammar rejects storage classes
10841          in typenames, fields or parameters.  */
10842       if (current_lang_name == lang_name_java)
10843         TYPE_FOR_JAVA (type) = 1;
10844
10845       if (decl_context == FIELD)
10846         {
10847           if (declarator == constructor_name (current_class_type))
10848             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10849                         declarator);
10850           decl = build_lang_decl (TYPE_DECL, declarator, type);
10851         }
10852       else
10853         {
10854           /* Make sure this typedef lives as long as its type,
10855              since it might be used as a template parameter. */
10856           if (processing_template_decl)
10857             decl = build_lang_decl (TYPE_DECL, declarator, type);
10858           else
10859             decl = build_decl (TYPE_DECL, declarator, type);
10860         }
10861
10862       /* If the user declares "typedef struct {...} foo" then the
10863          struct will have an anonymous name.  Fill that name in now.
10864          Nothing can refer to it, so nothing needs know about the name
10865          change.  */
10866       if (type != error_mark_node
10867           && TYPE_NAME (type)
10868           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10869           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10870           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10871         {
10872           tree oldname = TYPE_NAME (type);
10873           tree t;
10874
10875           /* Replace the anonymous name with the real name everywhere.  */
10876           lookup_tag_reverse (type, declarator);
10877           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10878             if (TYPE_NAME (t) == oldname)
10879               TYPE_NAME (t) = decl;
10880
10881           if (TYPE_LANG_SPECIFIC (type))
10882             TYPE_WAS_ANONYMOUS (type) = 1;
10883
10884           /* If this is a typedef within a template class, the nested
10885              type is a (non-primary) template.  The name for the
10886              template needs updating as well.  */
10887           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10888             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10889               = TYPE_IDENTIFIER (type);
10890
10891           /* XXX Temporarily set the scope.
10892              When returning, start_decl expects it as NULL_TREE,
10893              and will then then set it using pushdecl. */
10894           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10895           if (current_class_type)
10896             DECL_CONTEXT (decl) = current_class_type;
10897           else
10898             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10899
10900           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10901           DECL_ASSEMBLER_NAME (decl)
10902             = get_identifier (build_overload_name (type, 1, 1));
10903           DECL_CONTEXT (decl) = NULL_TREE;
10904
10905           /* FIXME remangle member functions; member functions of a
10906              type with external linkage have external linkage.  */
10907         }
10908
10909       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10910         {
10911           cp_error_at ("typedef name may not be class-qualified", decl);
10912           return NULL_TREE;
10913         }
10914       else if (quals)
10915         {
10916           if (ctype == NULL_TREE)
10917             {
10918               if (TREE_CODE (type) != METHOD_TYPE)
10919                 cp_error_at ("invalid type qualifier for non-member function type", decl);
10920               else
10921                 ctype = TYPE_METHOD_BASETYPE (type);
10922             }
10923           if (ctype != NULL_TREE)
10924             grok_method_quals (ctype, decl, quals);
10925         }
10926
10927       if (RIDBIT_SETP (RID_SIGNED, specbits)
10928           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10929         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10930
10931       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
10932                       inlinep, friendp, raises != NULL_TREE);
10933
10934       if (initialized)
10935         error ("typedef declaration includes an initializer");
10936
10937       return decl;
10938     }
10939
10940   /* Detect the case of an array type of unspecified size
10941      which came, as such, direct from a typedef name.
10942      We must copy the type, so that each identifier gets
10943      a distinct type, so that each identifier's size can be
10944      controlled separately by its own initializer.  */
10945
10946   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
10947       && TYPE_DOMAIN (type) == NULL_TREE)
10948     {
10949       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
10950     }
10951
10952   /* If this is a type name (such as, in a cast or sizeof),
10953      compute the type and return it now.  */
10954
10955   if (decl_context == TYPENAME)
10956     {
10957       /* Note that the grammar rejects storage classes
10958          in typenames, fields or parameters.  */
10959       if (type_quals != TYPE_UNQUALIFIED)
10960         type_quals = TYPE_UNQUALIFIED;
10961
10962       /* Special case: "friend class foo" looks like a TYPENAME context.  */
10963       if (friendp)
10964         {
10965           if (type_quals != TYPE_UNQUALIFIED)
10966             {
10967               cp_error ("type qualifiers specified for friend class declaration");
10968               type_quals = TYPE_UNQUALIFIED;
10969             }
10970           if (inlinep)
10971             {
10972               cp_error ("`inline' specified for friend class declaration");
10973               inlinep = 0;
10974             }
10975
10976           /* Only try to do this stuff if we didn't already give up.  */
10977           if (type != integer_type_node)
10978             {
10979               /* A friendly class?  */
10980               if (current_class_type)
10981                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
10982               else
10983                 error ("trying to make class `%s' a friend of global scope",
10984                        TYPE_NAME_STRING (type));
10985               type = void_type_node;
10986             }
10987         }
10988       else if (quals)
10989         {
10990           if (ctype == NULL_TREE)
10991             {
10992               if (TREE_CODE (type) != METHOD_TYPE)
10993                 cp_error ("invalid qualifiers on non-member function type");
10994               else
10995                 ctype = TYPE_METHOD_BASETYPE (type);
10996             }
10997           if (ctype)
10998             {
10999               tree dummy = build_decl (TYPE_DECL, declarator, type);
11000               grok_method_quals (ctype, dummy, quals);
11001               type = TREE_TYPE (dummy);
11002             }
11003         }
11004
11005       return type;
11006     }
11007   else if (declarator == NULL_TREE && decl_context != PARM
11008            && decl_context != CATCHPARM
11009            && TREE_CODE (type) != UNION_TYPE
11010            && ! bitfield)
11011     {
11012       cp_error ("abstract declarator `%T' used as declaration", type);
11013       declarator = make_anon_name ();
11014     }
11015
11016   /* `void' at top level (not within pointer)
11017      is allowed only in typedefs or type names.
11018      We don't complain about parms either, but that is because
11019      a better error message can be made later.  */
11020
11021   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11022     {
11023       if (! declarator)
11024         error ("unnamed variable or field declared void");
11025       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11026         {
11027           if (IDENTIFIER_OPNAME_P (declarator))
11028             my_friendly_abort (356);
11029           else
11030             error ("variable or field `%s' declared void", name);
11031         }
11032       else
11033         error ("variable or field declared void");
11034       type = integer_type_node;
11035     }
11036
11037   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11038      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11039
11040   if (decl_context == PARM || decl_context == CATCHPARM)
11041     {
11042       if (ctype || in_namespace)
11043         error ("cannot use `::' in parameter declaration");
11044
11045       /* A parameter declared as an array of T is really a pointer to T.
11046          One declared as a function is really a pointer to a function.
11047          One declared as a member is really a pointer to member.  */
11048
11049       if (TREE_CODE (type) == ARRAY_TYPE)
11050         {
11051           /* Transfer const-ness of array into that of type pointed to.  */
11052           type = build_pointer_type (TREE_TYPE (type));
11053           type_quals = TYPE_UNQUALIFIED;
11054         }
11055       else if (TREE_CODE (type) == FUNCTION_TYPE)
11056         type = build_pointer_type (type);
11057       else if (TREE_CODE (type) == OFFSET_TYPE)
11058         type = build_pointer_type (type);
11059       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11060         {
11061           error ("declaration of `%s' as void", name);
11062           return NULL_TREE;
11063         }
11064     }
11065
11066   {
11067     register tree decl;
11068
11069     if (decl_context == PARM)
11070       {
11071         decl = build_decl (PARM_DECL, declarator, type);
11072
11073         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11074                         inlinep, friendp, raises != NULL_TREE);
11075
11076         /* Compute the type actually passed in the parmlist,
11077            for the case where there is no prototype.
11078            (For example, shorts and chars are passed as ints.)
11079            When there is a prototype, this is overridden later.  */
11080
11081         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11082       }
11083     else if (decl_context == FIELD)
11084       {
11085         if (type == error_mark_node)
11086           {
11087             /* Happens when declaring arrays of sizes which
11088                are error_mark_node, for example.  */
11089             decl = NULL_TREE;
11090           }
11091         else if (in_namespace && !friendp)
11092           {
11093             /* Something like struct S { int N::j; };  */
11094             cp_error ("invalid use of `::'");
11095             decl = NULL_TREE;
11096           }
11097         else if (TREE_CODE (type) == FUNCTION_TYPE)
11098           {
11099             int publicp = 0;
11100             tree function_context;
11101
11102             /* We catch the others as conflicts with the builtin
11103                typedefs.  */
11104             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11105               {
11106                 cp_error ("function `%D' cannot be declared friend",
11107                           declarator);
11108                 friendp = 0;
11109               }
11110
11111             if (friendp == 0)
11112               {
11113                 if (ctype == NULL_TREE)
11114                   ctype = current_class_type;
11115
11116                 if (ctype == NULL_TREE)
11117                   {
11118                     cp_error ("can't make `%D' into a method -- not in a class",
11119                               declarator);
11120                     return void_type_node;
11121                   }
11122
11123                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11124                    ARM 9.5 */
11125                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11126                   {
11127                     cp_error ("function `%D' declared virtual inside a union",
11128                               declarator);
11129                     return void_type_node;
11130                   }
11131
11132                 if (declarator == ansi_opname[(int) NEW_EXPR]
11133                     || declarator == ansi_opname[(int) VEC_NEW_EXPR]
11134                     || declarator == ansi_opname[(int) DELETE_EXPR]
11135                     || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
11136                   {
11137                     if (virtualp)
11138                       {
11139                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11140                                   declarator);
11141                         virtualp = 0;
11142                       }
11143                   }
11144                 else if (staticp < 2)
11145                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11146                                                   TYPE_ARG_TYPES (type));
11147               }
11148
11149             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11150             function_context = (ctype != NULL_TREE) ?
11151               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11152             publicp = (! friendp || ! staticp)
11153               && function_context == NULL_TREE;
11154             decl = grokfndecl (ctype, type,
11155                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11156                                ? declarator : dname,
11157                                declarator,
11158                                virtualp, flags, quals, raises,
11159                                friendp ? -1 : 0, friendp, publicp, inlinep,
11160                                funcdef_flag, template_count, in_namespace);
11161             if (decl == NULL_TREE)
11162               return decl;
11163 #if 0
11164             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11165             /* The decl and setting of decl_machine_attr is also turned off.  */
11166             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11167 #endif
11168
11169             /* [class.conv.ctor]
11170
11171                A constructor declared without the function-specifier
11172                explicit that can be called with a single parameter
11173                specifies a conversion from the type of its first
11174                parameter to the type of its class.  Such a constructor
11175                is called a converting constructor.  */
11176             if (explicitp == 2)
11177               DECL_NONCONVERTING_P (decl) = 1;
11178             else if (DECL_CONSTRUCTOR_P (decl))
11179               {
11180                 /* The constructor can be called with exactly one
11181                    parameter if there is at least one parameter, and
11182                    any subsequent parameters have default arguments.
11183                    We don't look at the first parameter, which is
11184                    really just the `this' parameter for the new
11185                    object.  */
11186                 tree arg_types =
11187                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11188
11189                 /* Skip the `in_chrg' argument too, if present.  */
11190                 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl)))
11191                   arg_types = TREE_CHAIN (arg_types);
11192
11193                 if (arg_types == void_list_node
11194                     || (arg_types
11195                         && TREE_CHAIN (arg_types)
11196                         && TREE_CHAIN (arg_types) != void_list_node
11197                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11198                   DECL_NONCONVERTING_P (decl) = 1;
11199               }
11200           }
11201         else if (TREE_CODE (type) == METHOD_TYPE)
11202           {
11203             /* We only get here for friend declarations of
11204                members of other classes.  */
11205             /* All method decls are public, so tell grokfndecl to set
11206                TREE_PUBLIC, also.  */
11207             decl = grokfndecl (ctype, type, declarator, declarator,
11208                                virtualp, flags, quals, raises,
11209                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11210                                template_count, in_namespace);
11211             if (decl == NULL_TREE)
11212               return NULL_TREE;
11213           }
11214         else if (!staticp && ! processing_template_decl
11215                  && TYPE_SIZE (complete_type (type)) == NULL_TREE
11216                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11217           {
11218             if (declarator)
11219               cp_error ("field `%D' has incomplete type", declarator);
11220             else
11221               cp_error ("name `%T' has incomplete type", type);
11222
11223             /* If we're instantiating a template, tell them which
11224                instantiation made the field's type be incomplete.  */
11225             if (current_class_type
11226                 && TYPE_NAME (current_class_type)
11227                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11228                 && declspecs && TREE_VALUE (declspecs)
11229                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11230               cp_error ("  in instantiation of template `%T'",
11231                         current_class_type);
11232
11233             type = error_mark_node;
11234             decl = NULL_TREE;
11235           }
11236         else
11237           {
11238             if (friendp)
11239               {
11240                 error ("`%s' is neither function nor member function; cannot be declared friend",
11241                        IDENTIFIER_POINTER (declarator));
11242                 friendp = 0;
11243               }
11244             decl = NULL_TREE;
11245           }
11246
11247         if (friendp)
11248           {
11249             /* Friends are treated specially.  */
11250             if (ctype == current_class_type)
11251               warning ("member functions are implicitly friends of their class");
11252             else
11253               {
11254                 tree t = NULL_TREE;
11255                 if (decl && DECL_NAME (decl))
11256                   {
11257                     if (template_class_depth (current_class_type) == 0)
11258                       {
11259                         decl
11260                           = check_explicit_specialization
11261                           (declarator, decl,
11262                            template_count, 2 * (funcdef_flag != 0) + 4);
11263                         if (decl == error_mark_node)
11264                           return error_mark_node;
11265                       }
11266
11267                     t = do_friend (ctype, declarator, decl,
11268                                    last_function_parms, attrlist, flags, quals,
11269                                    funcdef_flag);
11270                   }
11271                 if (t && funcdef_flag)
11272                   return t;
11273
11274                 return void_type_node;
11275               }
11276           }
11277
11278         /* Structure field.  It may not be a function, except for C++ */
11279
11280         if (decl == NULL_TREE)
11281           {
11282             if (initialized)
11283               {
11284                 if (!staticp)
11285                   {
11286                     /* An attempt is being made to initialize a non-static
11287                        member.  But, from [class.mem]:
11288
11289                        4 A member-declarator can contain a
11290                        constant-initializer only if it declares a static
11291                        member (_class.static_) of integral or enumeration
11292                        type, see _class.static.data_.
11293
11294                        This used to be relatively common practice, but
11295                        the rest of the compiler does not correctly
11296                        handle the initialization unless the member is
11297                        static so we make it static below.  */
11298                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11299                                 declarator);
11300                     cp_pedwarn ("making `%D' static", declarator);
11301                     staticp = 1;
11302                   }
11303
11304                 if (uses_template_parms (type))
11305                   /* We'll check at instantiation time.  */
11306                   ;
11307                 else if (check_static_variable_definition (declarator,
11308                                                            type))
11309                   /* If we just return the declaration, crashes
11310                      will sometimes occur.  We therefore return
11311                      void_type_node, as if this was a friend
11312                      declaration, to cause callers to completely
11313                      ignore this declaration.  */
11314                   return void_type_node;
11315               }
11316
11317             /* 9.2p13 [class.mem] */
11318             if (declarator == constructor_name (current_class_type)
11319                 /* Divergence from the standard:  In extern "C", we
11320                    allow non-static data members here, because C does
11321                    and /usr/include/netinet/in.h uses that.  */
11322                 && (staticp || ! in_system_header))
11323               cp_pedwarn ("ISO C++ forbids data member `%D' with same name as enclosing class",
11324                           declarator);
11325
11326             if (staticp)
11327               {
11328                 /* C++ allows static class members.  All other work
11329                    for this is done by grokfield.  */
11330                 decl = build_lang_decl (VAR_DECL, declarator, type);
11331                 TREE_STATIC (decl) = 1;
11332                 /* In class context, 'static' means public access.  */
11333                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11334               }
11335             else
11336               {
11337                 decl = build_lang_decl (FIELD_DECL, declarator, type);
11338                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11339                   {
11340                     DECL_MUTABLE_P (decl) = 1;
11341                     RIDBIT_RESET (RID_MUTABLE, specbits);
11342                   }
11343               }
11344
11345             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11346                             inlinep, friendp, raises != NULL_TREE);
11347           }
11348       }
11349     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11350       {
11351         tree original_name;
11352         int publicp = 0;
11353
11354         if (! declarator)
11355           return NULL_TREE;
11356
11357         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11358           original_name = dname;
11359         else
11360           original_name = declarator;
11361
11362         if (RIDBIT_SETP (RID_AUTO, specbits))
11363           error ("storage class `auto' invalid for function `%s'", name);
11364         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11365           error ("storage class `register' invalid for function `%s'", name);
11366
11367         /* Function declaration not at top level.
11368            Storage classes other than `extern' are not allowed
11369            and `extern' makes no difference.  */
11370         if (! toplevel_bindings_p ()
11371             && (RIDBIT_SETP (RID_STATIC, specbits)
11372                 || RIDBIT_SETP (RID_INLINE, specbits))
11373             && pedantic)
11374           {
11375             if (RIDBIT_SETP (RID_STATIC, specbits))
11376               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11377             else
11378               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11379           }
11380
11381         if (ctype == NULL_TREE)
11382           {
11383             if (virtualp)
11384               {
11385                 error ("virtual non-class function `%s'", name);
11386                 virtualp = 0;
11387               }
11388           }
11389         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11390           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11391                                           TYPE_ARG_TYPES (type));
11392
11393         /* Record presence of `static'.  */
11394         publicp = (ctype != NULL_TREE
11395                    || RIDBIT_SETP (RID_EXTERN, specbits)
11396                    || !RIDBIT_SETP (RID_STATIC, specbits));
11397
11398         decl = grokfndecl (ctype, type, original_name, declarator,
11399                            virtualp, flags, quals, raises,
11400                            1, friendp,
11401                            publicp, inlinep, funcdef_flag,
11402                            template_count, in_namespace);
11403         if (decl == NULL_TREE)
11404           return NULL_TREE;
11405
11406         if (staticp == 1)
11407           {
11408             int illegal_static = 0;
11409
11410             /* Don't allow a static member function in a class, and forbid
11411                declaring main to be static.  */
11412             if (TREE_CODE (type) == METHOD_TYPE)
11413               {
11414                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11415                 illegal_static = 1;
11416               }
11417             else if (current_function_decl)
11418               {
11419                 /* FIXME need arm citation */
11420                 error ("cannot declare static function inside another function");
11421                 illegal_static = 1;
11422               }
11423
11424             if (illegal_static)
11425               {
11426                 staticp = 0;
11427                 RIDBIT_RESET (RID_STATIC, specbits);
11428               }
11429           }
11430       }
11431     else
11432       {
11433         /* It's a variable.  */
11434
11435         /* An uninitialized decl with `extern' is a reference.  */
11436         decl = grokvardecl (type, declarator, &specbits,
11437                             initialized,
11438                             (type_quals & TYPE_QUAL_CONST) != 0,
11439                             in_namespace);
11440         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11441                         inlinep, friendp, raises != NULL_TREE);
11442
11443         if (ctype)
11444           {
11445             DECL_CONTEXT (decl) = ctype;
11446             if (staticp == 1)
11447               {
11448                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11449                 staticp = 0;
11450                 RIDBIT_RESET (RID_STATIC, specbits);
11451               }
11452             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11453               {
11454                 cp_error ("static member `%D' declared `register'", decl);
11455                 RIDBIT_RESET (RID_REGISTER, specbits);
11456               }
11457             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11458               {
11459                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11460                             decl);
11461                 RIDBIT_RESET (RID_EXTERN, specbits);
11462               }
11463           }
11464       }
11465
11466     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11467
11468     /* Record `register' declaration for warnings on &
11469        and in case doing stupid register allocation.  */
11470
11471     if (RIDBIT_SETP (RID_REGISTER, specbits))
11472       DECL_REGISTER (decl) = 1;
11473
11474     if (RIDBIT_SETP (RID_EXTERN, specbits))
11475       DECL_THIS_EXTERN (decl) = 1;
11476
11477     if (RIDBIT_SETP (RID_STATIC, specbits))
11478       DECL_THIS_STATIC (decl) = 1;
11479
11480     /* Record constancy and volatility.  There's no need to do this
11481        when processing a template; we'll do this for the instantiated
11482        declaration based on the type of DECL.  */
11483     if (!processing_template_decl)
11484       c_apply_type_quals_to_decl (type_quals, decl);
11485
11486     return decl;
11487   }
11488 }
11489 \f
11490 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11491    An empty exprlist is a parmlist.  An exprlist which
11492    contains only identifiers at the global level
11493    is a parmlist.  Otherwise, it is an exprlist.  */
11494
11495 int
11496 parmlist_is_exprlist (exprs)
11497      tree exprs;
11498 {
11499   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11500     return 0;
11501
11502   if (toplevel_bindings_p ())
11503     {
11504       /* At the global level, if these are all identifiers,
11505          then it is a parmlist.  */
11506       while (exprs)
11507         {
11508           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11509             return 1;
11510           exprs = TREE_CHAIN (exprs);
11511         }
11512       return 0;
11513     }
11514   return 1;
11515 }
11516
11517 /* Subroutine of start_function.  Ensure that each of the parameter
11518    types (as listed in PARMS) is complete, as is required for a
11519    function definition.  */
11520
11521 static void
11522 require_complete_types_for_parms (parms)
11523      tree parms;
11524 {
11525   for (; parms; parms = TREE_CHAIN (parms))
11526     {
11527       tree type = TREE_TYPE (parms);
11528
11529       /* Try to complete the TYPE.  */
11530       type = complete_type (type);
11531
11532       if (type == error_mark_node)
11533         continue;
11534
11535       if (TYPE_SIZE (type) == NULL_TREE)
11536         {
11537           if (DECL_NAME (parms))
11538             error ("parameter `%s' has incomplete type",
11539                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11540           else
11541             error ("parameter has incomplete type");
11542           TREE_TYPE (parms) = error_mark_node;
11543         }
11544       else
11545         layout_decl (parms, 0);
11546     }
11547 }
11548
11549 /* Returns non-zero if T is a local variable.  */
11550
11551 int
11552 local_variable_p (t)
11553      tree t;
11554 {
11555   if ((TREE_CODE (t) == VAR_DECL
11556        /* A VAR_DECL with a context that is a _TYPE is a static data
11557           member.  */
11558        && !TYPE_P (CP_DECL_CONTEXT (t))
11559        /* Any other non-local variable must be at namespace scope.  */
11560        && !DECL_NAMESPACE_SCOPE_P (t))
11561       || (TREE_CODE (t) == PARM_DECL))
11562     return 1;
11563
11564   return 0;
11565 }
11566
11567 /* Returns non-zero if T is an automatic local variable or a label.
11568    (These are the declarations that need to be remapped when the code
11569    containing them is duplicated.)  */
11570
11571 int
11572 nonstatic_local_decl_p (t)
11573      tree t;
11574 {
11575   return ((local_variable_p (t) && !TREE_STATIC (t))
11576           || TREE_CODE (t) == LABEL_DECL
11577           || TREE_CODE (t) == RESULT_DECL);
11578 }
11579
11580 /* Like local_variable_p, but suitable for use as a tree-walking
11581    function.  */
11582
11583 static tree
11584 local_variable_p_walkfn (tp, walk_subtrees, data)
11585      tree *tp;
11586      int *walk_subtrees ATTRIBUTE_UNUSED;
11587      void *data ATTRIBUTE_UNUSED;
11588 {
11589   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11590           ? *tp : NULL_TREE);
11591 }
11592
11593 /* Check that ARG, which is a default-argument expression for a
11594    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11595    something goes wrong.  DECL may also be a _TYPE node, rather than a
11596    DECL, if there is no DECL available.  */
11597
11598 tree
11599 check_default_argument (decl, arg)
11600      tree decl;
11601      tree arg;
11602 {
11603   tree var;
11604   tree decl_type;
11605
11606   if (TREE_CODE (arg) == DEFAULT_ARG)
11607     /* We get a DEFAULT_ARG when looking at an in-class declaration
11608        with a default argument.  Ignore the argument for now; we'll
11609        deal with it after the class is complete.  */
11610     return arg;
11611
11612   if (processing_template_decl || uses_template_parms (arg))
11613     /* We don't do anything checking until instantiation-time.  Note
11614        that there may be uninstantiated arguments even for an
11615        instantiated function, since default arguments are not
11616        instantiated until they are needed.  */
11617     return arg;
11618
11619   if (TYPE_P (decl))
11620     {
11621       decl_type = decl;
11622       decl = NULL_TREE;
11623     }
11624   else
11625     decl_type = TREE_TYPE (decl);
11626
11627   if (arg == error_mark_node
11628       || decl == error_mark_node
11629       || TREE_TYPE (arg) == error_mark_node
11630       || decl_type == error_mark_node)
11631     /* Something already went wrong.  There's no need to check
11632        further.  */
11633     return error_mark_node;
11634
11635   /* [dcl.fct.default]
11636
11637      A default argument expression is implicitly converted to the
11638      parameter type.  */
11639   if (!TREE_TYPE (arg)
11640       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11641     {
11642       if (decl)
11643         cp_error ("default argument for `%#D' has type `%T'",
11644                   decl, TREE_TYPE (arg));
11645       else
11646         cp_error ("default argument for parameter of type `%T' has type `%T'",
11647                   decl_type, TREE_TYPE (arg));
11648
11649       return error_mark_node;
11650     }
11651
11652   /* [dcl.fct.default]
11653
11654      Local variables shall not be used in default argument
11655      expressions.
11656
11657      The keyword `this' shall not be used in a default argument of a
11658      member function.  */
11659   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11660   if (var)
11661     {
11662       cp_error ("default argument `%E' uses local variable `%D'",
11663                 arg, var);
11664       return error_mark_node;
11665     }
11666
11667   /* All is well.  */
11668   return arg;
11669 }
11670
11671 /* Decode the list of parameter types for a function type.
11672    Given the list of things declared inside the parens,
11673    return a list of types.
11674
11675    The list we receive can have three kinds of elements:
11676    an IDENTIFIER_NODE for names given without types,
11677    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11678    or void_type_node, to mark the end of an argument list
11679    when additional arguments are not permitted (... was not used).
11680
11681    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11682    a mere declaration.  A nonempty identifier-list gets an error message
11683    when FUNCDEF_FLAG is zero.
11684    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11685    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11686
11687    If all elements of the input list contain types,
11688    we return a list of the types.
11689    If all elements contain no type (except perhaps a void_type_node
11690    at the end), we return a null list.
11691    If some have types and some do not, it is an error, and we
11692    return a null list.
11693
11694    Also set last_function_parms to either
11695    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11696    A list of names is converted to a chain of PARM_DECLs
11697    by store_parm_decls so that ultimately it is always a chain of decls.
11698
11699    Note that in C++, parameters can take default values.  These default
11700    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11701    an error to specify default values which are followed by parameters
11702    that have no default values, or an ELLIPSES.  For simplicities sake,
11703    only parameters which are specified with their types can take on
11704    default values.  */
11705
11706 static tree
11707 grokparms (first_parm, funcdef_flag)
11708      tree first_parm;
11709      int funcdef_flag;
11710 {
11711   tree result = NULL_TREE;
11712   tree decls = NULL_TREE;
11713
11714   if (first_parm != NULL_TREE
11715       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11716     {
11717       if (! funcdef_flag)
11718         pedwarn ("parameter names (without types) in function declaration");
11719       last_function_parms = first_parm;
11720       return NULL_TREE;
11721     }
11722   else if (first_parm != NULL_TREE
11723            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11724            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11725     my_friendly_abort (145);
11726   else
11727     {
11728       /* Types were specified.  This is a list of declarators
11729          each represented as a TREE_LIST node.  */
11730       register tree parm, chain;
11731       int any_init = 0, any_error = 0;
11732
11733       if (first_parm != NULL_TREE)
11734         {
11735           tree last_result = NULL_TREE;
11736           tree last_decl = NULL_TREE;
11737
11738           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11739             {
11740               tree type = NULL_TREE, list_node = parm;
11741               register tree decl = TREE_VALUE (parm);
11742               tree init = TREE_PURPOSE (parm);
11743
11744               chain = TREE_CHAIN (parm);
11745               /* @@ weak defense against parse errors.  */
11746               if (TREE_CODE (decl) != VOID_TYPE
11747                   && TREE_CODE (decl) != TREE_LIST)
11748                 {
11749                   /* Give various messages as the need arises.  */
11750                   if (TREE_CODE (decl) == STRING_CST)
11751                     cp_error ("invalid string constant `%E'", decl);
11752                   else if (TREE_CODE (decl) == INTEGER_CST)
11753                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11754                   continue;
11755                 }
11756
11757               if (TREE_CODE (decl) != VOID_TYPE)
11758                 {
11759                   decl = grokdeclarator (TREE_VALUE (decl),
11760                                          TREE_PURPOSE (decl),
11761                                          PARM, init != NULL_TREE,
11762                                          NULL_TREE);
11763                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11764                     continue;
11765
11766                   /* Top-level qualifiers on the parameters are
11767                      ignored for function types.  */
11768                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11769
11770                   if (TREE_CODE (type) == VOID_TYPE)
11771                     decl = void_type_node;
11772                   else if (TREE_CODE (type) == METHOD_TYPE)
11773                     {
11774                       if (DECL_NAME (decl))
11775                         /* Cannot use the decl here because
11776                            we don't have DECL_CONTEXT set up yet.  */
11777                         cp_error ("parameter `%D' invalidly declared method type",
11778                                   DECL_NAME (decl));
11779                       else
11780                         error ("parameter invalidly declared method type");
11781                       type = build_pointer_type (type);
11782                       TREE_TYPE (decl) = type;
11783                     }
11784                   else if (TREE_CODE (type) == OFFSET_TYPE)
11785                     {
11786                       if (DECL_NAME (decl))
11787                         cp_error ("parameter `%D' invalidly declared offset type",
11788                                   DECL_NAME (decl));
11789                       else
11790                         error ("parameter invalidly declared offset type");
11791                       type = build_pointer_type (type);
11792                       TREE_TYPE (decl) = type;
11793                     }
11794                   else if (abstract_virtuals_error (decl, type))
11795                     any_error = 1;  /* Seems like a good idea. */
11796                   else if (POINTER_TYPE_P (type))
11797                     {
11798                       tree t = type;
11799                       while (POINTER_TYPE_P (t)
11800                              || (TREE_CODE (t) == ARRAY_TYPE
11801                                  && TYPE_DOMAIN (t) != NULL_TREE))
11802                         t = TREE_TYPE (t);
11803                       if (TREE_CODE (t) == ARRAY_TYPE)
11804                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
11805                                   type,
11806                                   TYPE_PTR_P (type) ? "pointer" : "reference");
11807                     }
11808                 }
11809
11810               if (TREE_CODE (decl) == VOID_TYPE)
11811                 {
11812                   if (result == NULL_TREE)
11813                     {
11814                       result = void_list_node;
11815                       last_result = result;
11816                     }
11817                   else
11818                     {
11819                       TREE_CHAIN (last_result) = void_list_node;
11820                       last_result = void_list_node;
11821                     }
11822                   if (chain
11823                       && (chain != void_list_node || TREE_CHAIN (chain)))
11824                     error ("`void' in parameter list must be entire list");
11825                   break;
11826                 }
11827
11828               /* Since there is a prototype, args are passed in their own types.  */
11829               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11830               if (PROMOTE_PROTOTYPES
11831                   && (TREE_CODE (type) == INTEGER_TYPE
11832                       || TREE_CODE (type) == ENUMERAL_TYPE)
11833                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11834                 DECL_ARG_TYPE (decl) = integer_type_node;
11835               if (!any_error && init)
11836                 {
11837                   any_init++;
11838                   init = check_default_argument (decl, init);
11839                 }
11840               else
11841                 init = NULL_TREE;
11842
11843               if (decls == NULL_TREE)
11844                 {
11845                   decls = decl;
11846                   last_decl = decls;
11847                 }
11848               else
11849                 {
11850                   TREE_CHAIN (last_decl) = decl;
11851                   last_decl = decl;
11852                 }
11853               list_node = tree_cons (init, type, NULL_TREE);
11854               if (result == NULL_TREE)
11855                 {
11856                   result = list_node;
11857                   last_result = result;
11858                 }
11859               else
11860                 {
11861                   TREE_CHAIN (last_result) = list_node;
11862                   last_result = list_node;
11863                 }
11864             }
11865           if (last_result)
11866             TREE_CHAIN (last_result) = NULL_TREE;
11867           /* If there are no parameters, and the function does not end
11868              with `...', then last_decl will be NULL_TREE.  */
11869           if (last_decl != NULL_TREE)
11870             TREE_CHAIN (last_decl) = NULL_TREE;
11871         }
11872     }
11873
11874   last_function_parms = decls;
11875
11876   return result;
11877 }
11878
11879 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11880    FUNCTION_TYPE with the newly parsed version of its default argument, which
11881    was previously digested as text.  See snarf_defarg et al in lex.c.  */
11882
11883 void
11884 replace_defarg (arg, init)
11885      tree arg, init;
11886 {
11887   if (! processing_template_decl
11888       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11889     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11890                 TREE_TYPE (init), TREE_VALUE (arg));
11891   TREE_PURPOSE (arg) = init;
11892 }
11893 \f
11894 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11895    D's arguments allow it to be a copy constructor, or copy assignment
11896    operator.  */
11897
11898 int
11899 copy_args_p (d)
11900      tree d;
11901 {
11902   tree t;
11903
11904   if (!DECL_FUNCTION_MEMBER_P (d))
11905     return 0;
11906
11907   t = FUNCTION_ARG_CHAIN (d);
11908   if (DECL_CONSTRUCTOR_P (d)
11909       && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
11910     t = TREE_CHAIN (t);
11911   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11912       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11913           == DECL_CONTEXT (d))
11914       && (TREE_CHAIN (t) == NULL_TREE
11915           || TREE_CHAIN (t) == void_list_node
11916           || TREE_PURPOSE (TREE_CHAIN (t))))
11917     return 1;
11918   return 0;
11919 }
11920
11921 /* These memoizing functions keep track of special properties which
11922    a class may have.  `grok_ctor_properties' notices whether a class
11923    has a constructor of the form X(X&), and also complains
11924    if the class has a constructor of the form X(X).
11925    `grok_op_properties' takes notice of the various forms of
11926    operator= which are defined, as well as what sorts of type conversion
11927    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11928
11929 int
11930 grok_ctor_properties (ctype, decl)
11931      tree ctype, decl;
11932 {
11933   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11934   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11935
11936   /* When a type has virtual baseclasses, a magical first int argument is
11937      added to any ctor so we can tell if the class has been initialized
11938      yet.  This could screw things up in this function, so we deliberately
11939      ignore the leading int if we're in that situation.  */
11940   if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
11941     {
11942       my_friendly_assert (parmtypes
11943                           && TREE_VALUE (parmtypes) == integer_type_node,
11944                           980529);
11945       parmtypes = TREE_CHAIN (parmtypes);
11946       parmtype = TREE_VALUE (parmtypes);
11947     }
11948
11949   /* [class.copy]
11950
11951      A non-template constructor for class X is a copy constructor if
11952      its first parameter is of type X&, const X&, volatile X& or const
11953      volatile X&, and either there are no other parameters or else all
11954      other parameters have default arguments.  */
11955   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11956       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11957       && (TREE_CHAIN (parmtypes) == NULL_TREE
11958           || TREE_CHAIN (parmtypes) == void_list_node
11959           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11960       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11961            && is_member_template (DECL_TI_TEMPLATE (decl))))
11962     {
11963       TYPE_HAS_INIT_REF (ctype) = 1;
11964       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11965         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11966     }
11967   /* [class.copy]
11968
11969      A declaration of a constructor for a class X is ill-formed if its
11970      first parameter is of type (optionally cv-qualified) X and either
11971      there are no other parameters or else all other parameters have
11972      default arguments.
11973
11974      We *don't* complain about member template instantiations that
11975      have this form, though; they can occur as we try to decide what
11976      constructor to use during overload resolution.  Since overload
11977      resolution will never prefer such a constructor to the
11978      non-template copy constructor (which is either explicitly or
11979      implicitly defined), there's no need to worry about their
11980      existence.  Theoretically, they should never even be
11981      instantiated, but that's hard to forestall.  */
11982   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11983            && (TREE_CHAIN (parmtypes) == NULL_TREE
11984                || TREE_CHAIN (parmtypes) == void_list_node
11985                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11986            && !(DECL_TEMPLATE_INSTANTIATION (decl)
11987                 && is_member_template (DECL_TI_TEMPLATE (decl))))
11988     {
11989       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11990                 ctype, ctype);
11991       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
11992       return 0;
11993     }
11994   else if (TREE_CODE (parmtype) == VOID_TYPE
11995            || TREE_PURPOSE (parmtypes) != NULL_TREE)
11996     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
11997
11998   return 1;
11999 }
12000
12001 /* An operator with this name can be either unary or binary.  */
12002
12003 static int
12004 ambi_op_p (name)
12005      tree name;
12006 {
12007   return (name == ansi_opname [(int) INDIRECT_REF]
12008           || name == ansi_opname [(int) ADDR_EXPR]
12009           || name == ansi_opname [(int) NEGATE_EXPR]
12010           || name == ansi_opname[(int) POSTINCREMENT_EXPR]
12011           || name == ansi_opname[(int) POSTDECREMENT_EXPR]
12012           || name == ansi_opname [(int) CONVERT_EXPR]);
12013 }
12014
12015 /* An operator with this name can only be unary.  */
12016
12017 static int
12018 unary_op_p (name)
12019      tree name;
12020 {
12021   return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
12022           || name == ansi_opname [(int) BIT_NOT_EXPR]
12023           || name == ansi_opname [(int) COMPONENT_REF]
12024           || IDENTIFIER_TYPENAME_P (name));
12025 }
12026
12027 /* Do a little sanity-checking on how they declared their operator.  */
12028
12029 void
12030 grok_op_properties (decl, virtualp, friendp)
12031      tree decl;
12032      int virtualp, friendp;
12033 {
12034   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12035   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12036   tree name = DECL_NAME (decl);
12037
12038   if (current_class_type == NULL_TREE)
12039     friendp = 1;
12040
12041   if (! friendp)
12042     {
12043       /* [class.copy]
12044
12045          A user-declared copy assignment operator X::operator= is a
12046          non-static non-template member function of class X with
12047          exactly one parameter of type X, X&, const X&, volatile X& or
12048          const volatile X&.  */
12049       if (name == ansi_opname[(int) MODIFY_EXPR]
12050           && !(DECL_TEMPLATE_INSTANTIATION (decl)
12051                && is_member_template (DECL_TI_TEMPLATE (decl))))
12052         ;
12053       else if (name == ansi_opname[(int) CALL_EXPR])
12054         TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12055       else if (name == ansi_opname[(int) ARRAY_REF])
12056         TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12057       else if (name == ansi_opname[(int) COMPONENT_REF]
12058                || name == ansi_opname[(int) MEMBER_REF])
12059         TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12060       else if (name == ansi_opname[(int) NEW_EXPR])
12061         TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12062       else if (name == ansi_opname[(int) DELETE_EXPR])
12063         TYPE_GETS_DELETE (current_class_type) |= 1;
12064       else if (name == ansi_opname[(int) VEC_NEW_EXPR])
12065         TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12066       else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
12067         TYPE_GETS_DELETE (current_class_type) |= 2;
12068     }
12069
12070   if (name == ansi_opname[(int) NEW_EXPR]
12071       || name == ansi_opname[(int) VEC_NEW_EXPR])
12072     {
12073       /* When the compiler encounters the definition of A::operator new, it
12074          doesn't look at the class declaration to find out if it's static.  */
12075       if (methodp)
12076         revert_static_member_fn (decl);
12077
12078       /* Take care of function decl if we had syntax errors.  */
12079       if (argtypes == NULL_TREE)
12080         TREE_TYPE (decl)
12081           = build_function_type (ptr_type_node,
12082                                  hash_tree_chain (integer_type_node,
12083                                                   void_list_node));
12084       else
12085         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12086     }
12087   else if (name == ansi_opname[(int) DELETE_EXPR]
12088            || name == ansi_opname[(int) VEC_DELETE_EXPR])
12089     {
12090       if (methodp)
12091         revert_static_member_fn (decl);
12092
12093       if (argtypes == NULL_TREE)
12094         TREE_TYPE (decl)
12095           = build_function_type (void_type_node,
12096                                  hash_tree_chain (ptr_type_node,
12097                                                   void_list_node));
12098       else
12099         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12100     }
12101   else
12102     {
12103       /* An operator function must either be a non-static member function
12104          or have at least one parameter of a class, a reference to a class,
12105          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12106       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12107         {
12108           if (IDENTIFIER_TYPENAME_P (name)
12109               || name == ansi_opname[(int) CALL_EXPR]
12110               || name == ansi_opname[(int) MODIFY_EXPR]
12111               || name == ansi_opname[(int) COMPONENT_REF]
12112               || name == ansi_opname[(int) ARRAY_REF])
12113             cp_error ("`%D' must be a nonstatic member function", decl);
12114           else
12115             {
12116               tree p = argtypes;
12117
12118               if (DECL_STATIC_FUNCTION_P (decl))
12119                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12120
12121               if (p)
12122                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12123                   {
12124                     tree arg = TREE_VALUE (p);
12125                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12126                       arg = TREE_TYPE (arg);
12127
12128                     /* This lets bad template code slip through.  */
12129                     if (IS_AGGR_TYPE (arg)
12130                         || TREE_CODE (arg) == ENUMERAL_TYPE
12131                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12132                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12133                       goto foundaggr;
12134                   }
12135               cp_error
12136                 ("`%D' must have an argument of class or enumerated type",
12137                  decl);
12138             foundaggr:
12139               ;
12140             }
12141         }
12142
12143       if (name == ansi_opname[(int) CALL_EXPR])
12144         return;                 /* No restrictions on args. */
12145
12146       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12147         {
12148           tree t = TREE_TYPE (name);
12149           if (! friendp)
12150             {
12151               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12152               const char *what = 0;
12153
12154               if (ref)
12155                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12156
12157               if (TREE_CODE (t) == VOID_TYPE)
12158                 what = "void";
12159               else if (t == current_class_type)
12160                 what = "the same type";
12161               /* Don't force t to be complete here.  */
12162               else if (IS_AGGR_TYPE (t)
12163                        && TYPE_SIZE (t)
12164                        && DERIVED_FROM_P (t, current_class_type))
12165                 what = "a base class";
12166
12167               if (what)
12168                 warning ("conversion to %s%s will never use a type conversion operator",
12169                          ref ? "a reference to " : "", what);
12170             }
12171         }
12172
12173       if (name == ansi_opname[(int) MODIFY_EXPR])
12174         {
12175           tree parmtype;
12176
12177           if (list_length (argtypes) != 3 && methodp)
12178             {
12179               cp_error ("`%D' must take exactly one argument", decl);
12180               return;
12181             }
12182           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12183
12184           if (copy_assignment_arg_p (parmtype, virtualp)
12185               && ! friendp)
12186             {
12187               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12188               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12189                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12190                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12191             }
12192         }
12193       else if (name == ansi_opname[(int) COND_EXPR])
12194         {
12195           /* 13.4.0.3 */
12196           cp_error ("ISO C++ prohibits overloading operator ?:");
12197         }
12198       else if (ambi_op_p (name))
12199         {
12200           if (list_length (argtypes) == 2)
12201             /* prefix */;
12202           else if (list_length (argtypes) == 3)
12203             {
12204               if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
12205                    || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12206                   && ! processing_template_decl
12207                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12208                 {
12209                   if (methodp)
12210                     cp_error ("postfix `%D' must take `int' as its argument",
12211                               decl);
12212                   else
12213                     cp_error
12214                       ("postfix `%D' must take `int' as its second argument",
12215                        decl);
12216                 }
12217             }
12218           else
12219             {
12220               if (methodp)
12221                 cp_error ("`%D' must take either zero or one argument", decl);
12222               else
12223                 cp_error ("`%D' must take either one or two arguments", decl);
12224             }
12225
12226           /* More Effective C++ rule 6.  */
12227           if (warn_ecpp
12228               && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12229                   || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
12230             {
12231               tree arg = TREE_VALUE (argtypes);
12232               tree ret = TREE_TYPE (TREE_TYPE (decl));
12233               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12234                 arg = TREE_TYPE (arg);
12235               arg = TYPE_MAIN_VARIANT (arg);
12236               if (list_length (argtypes) == 2)
12237                 {
12238                   if (TREE_CODE (ret) != REFERENCE_TYPE
12239                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12240                                        arg))
12241                     cp_warning ("prefix `%D' should return `%T'", decl,
12242                                 build_reference_type (arg));
12243                 }
12244               else
12245                 {
12246                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12247                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12248                 }
12249             }
12250         }
12251       else if (unary_op_p (name))
12252         {
12253           if (list_length (argtypes) != 2)
12254             {
12255               if (methodp)
12256                 cp_error ("`%D' must take `void'", decl);
12257               else
12258                 cp_error ("`%D' must take exactly one argument", decl);
12259             }
12260         }
12261       else /* if (binary_op_p (name)) */
12262         {
12263           if (list_length (argtypes) != 3)
12264             {
12265               if (methodp)
12266                 cp_error ("`%D' must take exactly one argument", decl);
12267               else
12268                 cp_error ("`%D' must take exactly two arguments", decl);
12269             }
12270
12271           /* More Effective C++ rule 7.  */
12272           if (warn_ecpp
12273               && (name == ansi_opname [TRUTH_ANDIF_EXPR]
12274                   || name == ansi_opname [TRUTH_ORIF_EXPR]
12275                   || name == ansi_opname [COMPOUND_EXPR]))
12276             cp_warning ("user-defined `%D' always evaluates both arguments",
12277                         decl);
12278         }
12279
12280       /* Effective C++ rule 23.  */
12281       if (warn_ecpp
12282           && list_length (argtypes) == 3
12283           && (name == ansi_opname [PLUS_EXPR]
12284               || name == ansi_opname [MINUS_EXPR]
12285               || name == ansi_opname [TRUNC_DIV_EXPR]
12286               || name == ansi_opname [MULT_EXPR])
12287           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12288         cp_warning ("`%D' should return by value", decl);
12289
12290       /* 13.4.0.8 */
12291       if (argtypes)
12292         for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
12293           if (TREE_PURPOSE (argtypes))
12294             {
12295               TREE_PURPOSE (argtypes) = NULL_TREE;
12296               if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12297                   || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12298                 {
12299                   if (pedantic)
12300                     cp_pedwarn ("`%D' cannot have default arguments", decl);
12301                 }
12302               else
12303                 cp_error ("`%D' cannot have default arguments", decl);
12304             }
12305     }
12306 }
12307 \f
12308 static const char *
12309 tag_name (code)
12310      enum tag_types code;
12311 {
12312   switch (code)
12313     {
12314     case record_type:
12315       return "struct";
12316     case class_type:
12317       return "class";
12318     case union_type:
12319       return "union ";
12320     case enum_type:
12321       return "enum";
12322     default:
12323       my_friendly_abort (981122);
12324     }
12325 }
12326
12327 /* Get the struct, enum or union (CODE says which) with tag NAME.
12328    Define the tag as a forward-reference if it is not defined.
12329
12330    C++: If a class derivation is given, process it here, and report
12331    an error if multiple derivation declarations are not identical.
12332
12333    If this is a definition, come in through xref_tag and only look in
12334    the current frame for the name (since C++ allows new names in any
12335    scope.)  */
12336
12337 tree
12338 xref_tag (code_type_node, name, globalize)
12339      tree code_type_node;
12340      tree name;
12341      int globalize;
12342 {
12343   enum tag_types tag_code;
12344   enum tree_code code;
12345   register tree ref, t;
12346   struct binding_level *b = current_binding_level;
12347   int got_type = 0;
12348   tree attributes = NULL_TREE;
12349   tree context = NULL_TREE;
12350
12351   /* If we are called from the parser, code_type_node will sometimes be a
12352      TREE_LIST.  This indicates that the user wrote
12353      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12354      use them later.  */
12355   if (TREE_CODE (code_type_node) == TREE_LIST)
12356     {
12357       attributes = TREE_PURPOSE (code_type_node);
12358       code_type_node = TREE_VALUE (code_type_node);
12359     }
12360
12361   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12362   switch (tag_code)
12363     {
12364     case record_type:
12365     case class_type:
12366       code = RECORD_TYPE;
12367       break;
12368     case union_type:
12369       code = UNION_TYPE;
12370       break;
12371     case enum_type:
12372       code = ENUMERAL_TYPE;
12373       break;
12374     default:
12375       my_friendly_abort (18);
12376     }
12377
12378   /* If a cross reference is requested, look up the type
12379      already defined for this tag and return it.  */
12380   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
12381     {
12382       t = name;
12383       name = TYPE_IDENTIFIER (t);
12384       got_type = 1;
12385     }
12386   else
12387     t = IDENTIFIER_TYPE_VALUE (name);
12388
12389   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12390       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12391     t = NULL_TREE;
12392
12393   if (! globalize)
12394     {
12395       /* If we know we are defining this tag, only look it up in
12396          this scope and don't try to find it as a type.  */
12397       ref = lookup_tag (code, name, b, 1);
12398     }
12399   else
12400     {
12401       if (t)
12402         {
12403           /* [dcl.type.elab] If the identifier resolves to a
12404              typedef-name or a template type-parameter, the
12405              elaborated-type-specifier is ill-formed.  */
12406           if (t != TYPE_MAIN_VARIANT (t)
12407               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12408             cp_pedwarn ("using typedef-name `%D' after `%s'",
12409                         TYPE_NAME (t), tag_name (tag_code));
12410           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12411             cp_error ("using template type parameter `%T' after `%s'",
12412                       t, tag_name (tag_code));
12413
12414           ref = t;
12415         }
12416       else
12417         ref = lookup_tag (code, name, b, 0);
12418
12419       if (! ref)
12420         {
12421           /* Try finding it as a type declaration.  If that wins,
12422              use it.  */
12423           ref = lookup_name (name, 1);
12424
12425           if (ref != NULL_TREE
12426               && processing_template_decl
12427               && DECL_CLASS_TEMPLATE_P (ref)
12428               && template_class_depth (current_class_type) == 0)
12429             /* Since GLOBALIZE is true, we're declaring a global
12430                template, so we want this type.  */
12431             ref = DECL_RESULT (ref);
12432
12433           if (ref && TREE_CODE (ref) == TYPE_DECL
12434               && TREE_CODE (TREE_TYPE (ref)) == code)
12435             ref = TREE_TYPE (ref);
12436           else
12437             ref = NULL_TREE;
12438         }
12439
12440       if (ref && current_class_type
12441           && template_class_depth (current_class_type)
12442           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12443         {
12444           /* Since GLOBALIZE is non-zero, we are not looking at a
12445              definition of this tag.  Since, in addition, we are currently
12446              processing a (member) template declaration of a template
12447              class, we must be very careful; consider:
12448
12449                template <class X>
12450                struct S1
12451
12452                template <class U>
12453                struct S2
12454                { template <class V>
12455                friend struct S1; };
12456
12457              Here, the S2::S1 declaration should not be confused with the
12458              outer declaration.  In particular, the inner version should
12459              have a template parameter of level 2, not level 1.  This
12460              would be particularly important if the member declaration
12461              were instead:
12462
12463                template <class V = U> friend struct S1;
12464
12465              say, when we should tsubst into `U' when instantiating
12466              S2.  On the other hand, when presented with:
12467
12468                  template <class T>
12469                  struct S1 {
12470                    template <class U>
12471                    struct S2 {};
12472                    template <class U>
12473                    friend struct S2;
12474                  };
12475
12476               we must find the inner binding eventually.  We
12477               accomplish this by making sure that the new type we
12478               create to represent this declaration has the right
12479               TYPE_CONTEXT.  */
12480           context = TYPE_CONTEXT (ref);
12481           ref = NULL_TREE;
12482         }
12483     }
12484
12485   if (! ref)
12486     {
12487       /* If no such tag is yet defined, create a forward-reference node
12488          and record it as the "definition".
12489          When a real declaration of this type is found,
12490          the forward-reference will be altered into a real type.  */
12491       if (code == ENUMERAL_TYPE)
12492         {
12493           cp_error ("use of enum `%#D' without previous declaration", name);
12494
12495           ref = make_node (ENUMERAL_TYPE);
12496
12497           /* Give the type a default layout like unsigned int
12498              to avoid crashing if it does not get defined.  */
12499           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12500           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12501           TREE_UNSIGNED (ref) = 1;
12502           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12503           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12504           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12505
12506           /* Enable us to recognize when a type is created in class context.
12507              To do nested classes correctly, this should probably be cleared
12508              out when we leave this classes scope.  Currently this in only
12509              done in `start_enum'.  */
12510
12511           pushtag (name, ref, globalize);
12512         }
12513       else
12514         {
12515           struct binding_level *old_b = class_binding_level;
12516
12517           ref = make_aggr_type (code);
12518           TYPE_CONTEXT (ref) = context;
12519
12520 #ifdef NONNESTED_CLASSES
12521           /* Class types don't nest the way enums do.  */
12522           class_binding_level = (struct binding_level *)0;
12523 #endif
12524           pushtag (name, ref, globalize);
12525           class_binding_level = old_b;
12526         }
12527     }
12528   else
12529     {
12530       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12531         redeclare_class_template (ref, current_template_parms);
12532     }
12533
12534   /* Until the type is defined, tentatively accept whatever
12535      structure tag the user hands us.  */
12536   if (TYPE_SIZE (ref) == NULL_TREE
12537       && ref != current_class_type
12538       /* Have to check this, in case we have contradictory tag info.  */
12539       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12540     {
12541       if (tag_code == class_type)
12542         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12543       else if (tag_code == record_type)
12544         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12545     }
12546
12547   TREE_TYPE (ref) = attributes;
12548
12549   return ref;
12550 }
12551
12552 tree
12553 xref_tag_from_type (old, id, globalize)
12554      tree old, id;
12555      int globalize;
12556 {
12557   tree code_type_node;
12558
12559   if (TREE_CODE (old) == RECORD_TYPE)
12560     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12561                       ? class_type_node : record_type_node);
12562   else
12563     code_type_node = union_type_node;
12564
12565   if (id == NULL_TREE)
12566     id = TYPE_IDENTIFIER (old);
12567
12568   return xref_tag (code_type_node, id, globalize);
12569 }
12570
12571 /* REF is a type (named NAME), for which we have just seen some
12572    baseclasses.  BINFO is a list of those baseclasses; the
12573    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12574    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12575    struct, or union.  */
12576
12577 void
12578 xref_basetypes (code_type_node, name, ref, binfo)
12579      tree code_type_node;
12580      tree name, ref;
12581      tree binfo;
12582 {
12583   /* In the declaration `A : X, Y, ... Z' we mark all the types
12584      (A, X, Y, ..., Z) so we can check for duplicates.  */
12585   tree binfos;
12586   tree base;
12587
12588   int i, len;
12589   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12590
12591   if (tag_code == union_type)
12592     {
12593       cp_error ("derived union `%T' invalid", ref);
12594       return;
12595     }
12596
12597   len = list_length (binfo);
12598
12599   /* First, make sure that any templates in base-classes are
12600      instantiated.  This ensures that if we call ourselves recursively
12601      we do not get confused about which classes are marked and which
12602      are not.  */
12603   for (base = binfo; base; base = TREE_CHAIN (base))
12604     complete_type (TREE_VALUE (base));
12605
12606   SET_CLASSTYPE_MARKED (ref);
12607   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12608
12609   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12610     {
12611       /* The base of a derived struct is public by default.  */
12612       int via_public
12613         = (TREE_PURPOSE (binfo) == access_public_node
12614            || TREE_PURPOSE (binfo) == access_public_virtual_node
12615            || (tag_code != class_type
12616                && (TREE_PURPOSE (binfo) == access_default_node
12617                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12618       int via_protected
12619         = (TREE_PURPOSE (binfo) == access_protected_node
12620            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12621       int via_virtual
12622         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12623            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12624            || TREE_PURPOSE (binfo) == access_public_virtual_node
12625            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12626       tree basetype = TREE_VALUE (binfo);
12627       tree base_binfo;
12628
12629       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12630         basetype = TREE_TYPE (basetype);
12631       if (!basetype
12632           || (TREE_CODE (basetype) != RECORD_TYPE
12633               && TREE_CODE (basetype) != TYPENAME_TYPE
12634               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12635               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12636         {
12637           cp_error ("base type `%T' fails to be a struct or class type",
12638                     TREE_VALUE (binfo));
12639           continue;
12640         }
12641
12642       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12643
12644       /* This code replaces similar code in layout_basetypes.
12645          We put the complete_type first for implicit `typename'.  */
12646       if (TYPE_SIZE (basetype) == NULL_TREE
12647           && ! (current_template_parms && uses_template_parms (basetype)))
12648         {
12649           cp_error ("base class `%T' has incomplete type", basetype);
12650           continue;
12651         }
12652       else
12653         {
12654           if (CLASSTYPE_MARKED (basetype))
12655             {
12656               if (basetype == ref)
12657                 cp_error ("recursive type `%T' undefined", basetype);
12658               else
12659                 cp_error ("duplicate base type `%T' invalid", basetype);
12660               continue;
12661             }
12662
12663           if (TYPE_FOR_JAVA (basetype)
12664               && (current_lang_stack
12665                   == &VARRAY_TREE (current_lang_base, 0)))
12666             TYPE_FOR_JAVA (ref) = 1;
12667
12668           /* Note that the BINFO records which describe individual
12669              inheritances are *not* shared in the lattice!  They
12670              cannot be shared because a given baseclass may be
12671              inherited with different `accessibility' by different
12672              derived classes.  (Each BINFO record describing an
12673              individual inheritance contains flags which say what
12674              the `accessibility' of that particular inheritance is.)  */
12675
12676           base_binfo
12677             = make_binfo (size_zero_node, basetype,
12678                           CLASS_TYPE_P (basetype)
12679                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12680                           CLASS_TYPE_P (basetype)
12681                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12682
12683           TREE_VEC_ELT (binfos, i) = base_binfo;
12684           TREE_VIA_PUBLIC (base_binfo) = via_public;
12685           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12686           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12687           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12688
12689           /* We need to unshare the binfos now so that lookups during class
12690              definition work.  */
12691           unshare_base_binfos (base_binfo);
12692
12693           SET_CLASSTYPE_MARKED (basetype);
12694
12695           /* We are free to modify these bits because they are meaningless
12696              at top level, and BASETYPE is a top-level type.  */
12697           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12698             {
12699               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12700               /* Converting to a virtual base class requires looking
12701                  up the offset of the virtual base.  */
12702               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12703             }
12704
12705           if (CLASS_TYPE_P (basetype))
12706             {
12707               TYPE_HAS_NEW_OPERATOR (ref)
12708                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12709               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12710                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12711               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12712               /* If the base-class uses multiple inheritance, so do we.  */
12713               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12714                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12715               /* Likewise, if converting to a base of the base may require
12716                  code, then we may need to generate code to convert to a
12717                  base as well.  */
12718               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12719                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12720             }
12721
12722           i += 1;
12723         }
12724     }
12725   if (i)
12726     TREE_VEC_LENGTH (binfos) = i;
12727   else
12728     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12729
12730   if (i > 1)
12731     {
12732       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12733       /* If there is more than one non-empty they cannot be at the same
12734          address.  */
12735       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12736     }
12737
12738   /* Unmark all the types.  */
12739   while (--i >= 0)
12740     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12741   CLEAR_CLASSTYPE_MARKED (ref);
12742
12743   /* Now that we know all the base-classes, set up the list of virtual
12744      bases.  */
12745   get_vbase_types (ref);
12746 }
12747
12748 \f
12749 /* Begin compiling the definition of an enumeration type.
12750    NAME is its name (or null if anonymous).
12751    Returns the type object, as yet incomplete.
12752    Also records info about it so that build_enumerator
12753    may be used to declare the individual values as they are read.  */
12754
12755 tree
12756 start_enum (name)
12757      tree name;
12758 {
12759   register tree enumtype = NULL_TREE;
12760   struct binding_level *b = current_binding_level;
12761
12762   /* If this is the real definition for a previous forward reference,
12763      fill in the contents in the same object that used to be the
12764      forward reference.  */
12765
12766   if (name != NULL_TREE)
12767     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12768
12769   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12770     {
12771       cp_error ("multiple definition of `%#T'", enumtype);
12772       cp_error_at ("previous definition here", enumtype);
12773       /* Clear out TYPE_VALUES, and start again.  */
12774       TYPE_VALUES (enumtype) = NULL_TREE;
12775     }
12776   else
12777     {
12778       enumtype = make_node (ENUMERAL_TYPE);
12779       pushtag (name, enumtype, 0);
12780     }
12781
12782   if (current_class_type)
12783     TREE_ADDRESSABLE (b->tags) = 1;
12784
12785   GNU_xref_decl (current_function_decl, enumtype);
12786   return enumtype;
12787 }
12788
12789 /* After processing and defining all the values of an enumeration type,
12790    install their decls in the enumeration type and finish it off.
12791    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12792    Returns ENUMTYPE.  */
12793
12794 tree
12795 finish_enum (enumtype)
12796      tree enumtype;
12797 {
12798   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12799   /* Calculate the maximum value of any enumerator in this type.  */
12800
12801   tree values = TYPE_VALUES (enumtype);
12802   if (values)
12803     {
12804       tree pair;
12805
12806       for (pair = values; pair; pair = TREE_CHAIN (pair))
12807         {
12808           tree decl;
12809           tree value;
12810
12811           /* The TREE_VALUE is a CONST_DECL for this enumeration
12812              constant.  */
12813           decl = TREE_VALUE (pair);
12814
12815           /* [dcl.enum]
12816
12817              Following the closing brace of an enum-specifier, each
12818              enumerator has the type of its enumeration.  Prior to the
12819              closing brace, the type of each enumerator is the type of
12820              its initializing value.  */
12821           TREE_TYPE (decl) = enumtype;
12822
12823           /* The DECL_INITIAL will be NULL if we are processing a
12824              template declaration and this enumeration constant had no
12825              explicit initializer.  */
12826           value = DECL_INITIAL (decl);
12827           if (value && !processing_template_decl)
12828             {
12829               /* Set the TREE_TYPE for the VALUE as well.  That's so
12830                  that when we call decl_constant_value we get an
12831                  entity of the right type (but with the constant
12832                  value).  Since we shouldn't ever call
12833                  decl_constant_value on a template type, there's no
12834                  reason to do that when processing_template_decl.
12835                  And, if the expression is something like a
12836                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12837                  wreak havoc on the intended type of the expression.
12838
12839                  Of course, there's also no point in trying to compute
12840                  minimum or maximum values if we're in a template.  */
12841               TREE_TYPE (value) = enumtype;
12842
12843               if (!minnode)
12844                 minnode = maxnode = value;
12845               else if (tree_int_cst_lt (maxnode, value))
12846                 maxnode = value;
12847               else if (tree_int_cst_lt (value, minnode))
12848                 minnode = value;
12849             }
12850
12851           if (processing_template_decl)
12852             /* If this is just a template, leave the CONST_DECL
12853                alone.  That way tsubst_copy will find CONST_DECLs for
12854                CONST_DECLs, and not INTEGER_CSTs.  */
12855             ;
12856           else
12857             /* In the list we're building up, we want the enumeration
12858                values, not the CONST_DECLs.  */
12859             TREE_VALUE (pair) = value;
12860         }
12861     }
12862   else
12863     maxnode = minnode = integer_zero_node;
12864
12865   TYPE_VALUES (enumtype) = nreverse (values);
12866
12867   if (processing_template_decl)
12868     {
12869       tree scope = current_scope ();
12870       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12871         add_tree (build_min (TAG_DEFN, enumtype));
12872     }
12873   else
12874     {
12875       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12876       int lowprec = min_precision (minnode, unsignedp);
12877       int highprec = min_precision (maxnode, unsignedp);
12878       int precision = MAX (lowprec, highprec);
12879       tree tem;
12880
12881       TYPE_SIZE (enumtype) = NULL_TREE;
12882
12883       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12884
12885       TYPE_PRECISION (enumtype) = precision;
12886       if (unsignedp)
12887         fixup_unsigned_type (enumtype);
12888       else
12889         fixup_signed_type (enumtype);
12890
12891       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12892         /* Use the width of the narrowest normal C type which is wide
12893            enough.  */
12894         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12895                                                     (precision, 1));
12896       else
12897         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12898
12899       TYPE_SIZE (enumtype) = 0;
12900       layout_type (enumtype);
12901
12902       /* Fix up all variant types of this enum type.  */
12903       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12904            tem = TYPE_NEXT_VARIANT (tem))
12905         {
12906           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12907           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12908           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12909           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12910           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12911           TYPE_MODE (tem) = TYPE_MODE (enumtype);
12912           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12913           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12914           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12915         }
12916
12917       /* Finish debugging output for this type.  */
12918       rest_of_type_compilation (enumtype, namespace_bindings_p ());
12919     }
12920
12921   return enumtype;
12922 }
12923
12924 /* Build and install a CONST_DECL for an enumeration constant of the
12925    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12926    Assignment of sequential values by default is handled here.  */
12927
12928 void
12929 build_enumerator (name, value, enumtype)
12930      tree name;
12931      tree value;
12932      tree enumtype;
12933 {
12934   tree decl;
12935   tree context;
12936   tree type;
12937   tree values;
12938
12939   /* Remove no-op casts from the value.  */
12940   if (value)
12941     STRIP_TYPE_NOPS (value);
12942
12943   if (! processing_template_decl)
12944     {
12945       /* Validate and default VALUE.  */
12946       if (value != NULL_TREE)
12947         {
12948           if (TREE_READONLY_DECL_P (value))
12949             value = decl_constant_value (value);
12950
12951           if (TREE_CODE (value) == INTEGER_CST)
12952             {
12953               value = default_conversion (value);
12954               constant_expression_warning (value);
12955             }
12956           else
12957             {
12958               cp_error ("enumerator value for `%D' not integer constant", name);
12959               value = NULL_TREE;
12960             }
12961         }
12962
12963       /* Default based on previous value.  */
12964       if (value == NULL_TREE && ! processing_template_decl)
12965         {
12966           tree prev_value;
12967
12968           if (TYPE_VALUES (enumtype))
12969             {
12970               /* The next value is the previous value ... */
12971               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
12972               /* ... plus one.  */
12973               value = build_binary_op (PLUS_EXPR,
12974                                        prev_value,
12975                                        integer_one_node);
12976
12977               if (tree_int_cst_lt (value, prev_value))
12978                 cp_error ("overflow in enumeration values at `%D'", name);
12979             }
12980           else
12981             value = integer_zero_node;
12982         }
12983
12984       /* Remove no-op casts from the value.  */
12985       if (value)
12986         STRIP_TYPE_NOPS (value);
12987 #if 0
12988       /* To fix MAX_VAL enum consts. (bkoz)  */
12989       TREE_TYPE (value) = integer_type_node;
12990 #endif
12991     }
12992
12993   /* We always have to copy here; not all INTEGER_CSTs are unshared.
12994      Even in other cases, we will later (in finish_enum) be setting
12995      the type of VALUE.  But, we don't need to make a copy if this
12996      VALUE is one of the enumeration constants for this same
12997      enumeration type.  */
12998   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
12999     if (TREE_VALUE (values) == value)
13000       break;
13001   /* If we didn't break out of the loop, then we do need a copy.  */
13002   if (!values && value)
13003     value = copy_node (value);
13004
13005   /* C++ associates enums with global, function, or class declarations.  */
13006   context = current_scope ();
13007
13008   /* Build the actual enumeration constant.  Note that the enumeration
13009     constants have the type of their initializers until the
13010     enumeration is complete:
13011
13012       [ dcl.enum ]
13013
13014       Following the closing brace of an enum-specifier, each enumer-
13015       ator has the type of its enumeration.  Prior to the closing
13016       brace, the type of each enumerator is the type of its
13017       initializing value.
13018
13019     In finish_enum we will reset the type.  Of course, if we're
13020     processing a template, there may be no value.   */
13021   type = value ? TREE_TYPE (value) : NULL_TREE;
13022
13023   if (context && context == current_class_type)
13024     /* This enum declaration is local to the class.  We need the full
13025       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13026     decl = build_lang_decl (CONST_DECL, name, type);
13027   else
13028     /* It's a global enum, or it's local to a function.  (Note local to
13029       a function could mean local to a class method.  */
13030     decl = build_decl (CONST_DECL, name, type);
13031
13032   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13033   DECL_INITIAL (decl) = value;
13034   TREE_READONLY (decl) = 1;
13035
13036   if (context && context == current_class_type)
13037     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13038       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13039       things like `S::i' later.)  */
13040     finish_member_declaration (decl);
13041   else
13042     {
13043       pushdecl (decl);
13044       GNU_xref_decl (current_function_decl, decl);
13045     }
13046
13047   /* Add this enumeration constant to the list for this type.  */
13048   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13049 }
13050
13051 \f
13052 static int function_depth;
13053
13054 /* We're defining DECL.  Make sure that it's type is OK.  */
13055
13056 static void
13057 check_function_type (decl)
13058      tree decl;
13059 {
13060   tree fntype = TREE_TYPE (decl);
13061
13062   /* In a function definition, arg types must be complete.  */
13063   require_complete_types_for_parms (current_function_parms);
13064
13065   if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
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 }