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