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 "defaults.h"
  41 #include "output.h"
  42 #include "except.h"
  43 #include "toplev.h"
  44 #include "../hash.h"
  45 #include "defaults.h"
  46 #include "ggc.h"
  47
  48 extern int current_class_depth;
  49
  50 extern tree static_ctors, static_dtors;
  51
  52 extern tree global_namespace;
  53
  54 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  55
  56 /* Use garbage collection.  */
  57
  58 int ggc_p = 1;
  59
  60 #ifndef WCHAR_UNSIGNED
  61 #define WCHAR_UNSIGNED 0
  62 #endif
  63
  64 #ifndef CHAR_TYPE_SIZE
  65 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  66 #endif
  67
  68 #ifndef BOOL_TYPE_SIZE
  69 #ifdef SLOW_BYTE_ACCESS
  70 /* In the new ABI, `bool' has size and alignment `1', on all
  71    platforms.  */
  72 #define BOOL_TYPE_SIZE \
  73   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  74 #else
  75 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  76 #endif
  77 #endif
  78
  79 /* We let tm.h override the types used here, to handle trivial differences
  80    such as the choice of unsigned int or long unsigned int for size_t.
  81    When machines start needing nontrivial differences in the size type,
  82    it would be best to do something here to figure out automatically
  83    from other information what type to use.  */
  84
  85 #ifndef SIZE_TYPE
  86 #define SIZE_TYPE "long unsigned int"
  87 #endif
  88
  89 #ifndef PTRDIFF_TYPE
  90 #define PTRDIFF_TYPE "long int"
  91 #endif
  92
  93 #ifndef WCHAR_TYPE
  94 #define WCHAR_TYPE "int"
  95 #endif
  96
  97 static tree grokparms                           PARAMS ((tree, int));
  98 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  99
 100 static void push_binding_level PARAMS ((struct binding_level *, int,
 101                                       int));
 102 static void pop_binding_level PARAMS ((void));
 103 static void suspend_binding_level PARAMS ((void));
 104 static void resume_binding_level PARAMS ((struct binding_level *));
 105 static struct binding_level *make_binding_level PARAMS ((void));
 106 static void declare_namespace_level PARAMS ((void));
 107 static void signal_catch PARAMS ((int)) ATTRIBUTE_NORETURN;
 108 static void storedecls PARAMS ((tree));
 109 static void require_complete_types_for_parms PARAMS ((tree));
 110 static int ambi_op_p PARAMS ((tree));
 111 static int unary_op_p PARAMS ((tree));
 112 static tree store_bindings PARAMS ((tree, tree));
 113 static tree lookup_tag_reverse PARAMS ((tree, tree));
 114 static tree obscure_complex_init PARAMS ((tree, tree));
 115 static tree maybe_build_cleanup_1 PARAMS ((tree, tree));
 116 static tree lookup_name_real PARAMS ((tree, int, int, int));
 117 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 118 static void grok_reference_init PARAMS ((tree, tree, tree));
 119 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 120                               enum overload_flags, tree,
 121                               tree, int, int, int, int, int, int, tree));
 122 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 123 static tree lookup_tag PARAMS ((enum tree_code, tree,
 124                               struct binding_level *, int));
 125 static void set_identifier_type_value_with_scope
 126         PARAMS ((tree, tree, struct binding_level *));
 127 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 128 static void record_unknown_type PARAMS ((tree, const char *));
 129 static tree build_library_fn_1                  PARAMS ((tree, tree));
 130 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 131 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 132                                   int));
 133 static void lang_print_error_function PARAMS ((const char *));
 134 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 135 static void check_for_uninitialized_const_var PARAMS ((tree));
 136 static unsigned long typename_hash PARAMS ((hash_table_key));
 137 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 138 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 139 static int add_binding PARAMS ((tree, tree));
 140 static void pop_binding PARAMS ((tree, tree));
 141 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 142 static tree find_binding PARAMS ((tree, tree));
 143 static tree select_decl PARAMS ((tree, int));
 144 static int lookup_flags PARAMS ((int, int));
 145 static tree qualify_lookup PARAMS ((tree, int));
 146 static tree record_builtin_java_type PARAMS ((const char *, int));
 147 static const char *tag_name PARAMS ((enum tag_types code));
 148 static void find_class_binding_level PARAMS ((void));
 149 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 150 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 151 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 152 static int walk_globals_r PARAMS ((tree, void *));
 153 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 154 static tree make_label_decl PARAMS ((tree, int));
 155 static void pop_label PARAMS ((tree));
 156 static void pop_labels PARAMS ((tree));
 157 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 158 static void layout_var_decl PARAMS ((tree));
 159 static void maybe_commonize_var PARAMS ((tree));
 160 static tree check_initializer PARAMS ((tree, tree));
 161 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 162 static void push_cp_function_context PARAMS ((struct function *));
 163 static void pop_cp_function_context PARAMS ((struct function *));
 164 static void mark_binding_level PARAMS ((void *));
 165 static void mark_cp_function_context PARAMS ((struct function *));
 166 static void mark_saved_scope PARAMS ((void *));
 167 static void mark_lang_function PARAMS ((struct language_function *));
 168 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 169 static void save_function_data PARAMS ((tree));
 170 static void check_function_type PARAMS ((tree));
 171 static void destroy_local_var PARAMS ((tree));
 172 static void finish_constructor_body PARAMS ((void));
 173 static void finish_destructor_body PARAMS ((void));
 174 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 175 static tree get_atexit_node PARAMS ((void));
 176 static tree get_dso_handle_node PARAMS ((void));
 177 static tree start_cleanup_fn PARAMS ((void));
 178 static void end_cleanup_fn PARAMS ((void));
 179 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 180 static void initialize_predefined_identifiers PARAMS ((void));
 181 static tree check_special_function_return_type
 182   PARAMS ((special_function_kind, tree, tree, tree));
 183
 184 #if defined (DEBUG_CP_BINDING_LEVELS)
 185 static void indent PARAMS ((void));
 186 #endif
 187
 188 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 189 tree error_mark_list;
 190
 191 /* The following symbols are subsumed in the cp_global_trees array, and
 192    listed here individually for documentation purposes.
 193
 194    C++ extensions
 195         tree wchar_decl_node;
 196         tree void_zero_node;
 197
 198         tree vtable_entry_type;
 199         tree delta_type_node;
 200 #if 0
 201    Old rtti stuff.
 202         tree __baselist_desc_type_node;
 203         tree __i_desc_type_node, __m_desc_type_node;
 204         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 205 #endif
 206         tree __t_desc_type_node;
 207 #if 0
 208         tree __tp_desc_type_node;
 209 #endif
 210         tree ti_desc_type_node;
 211         tree bltn_desc_type_node, ptr_desc_type_node;
 212         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 213         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 214         tree ptmd_desc_type_node;
 215         tree base_desc_type_node;
 216 #if 0
 217    Not needed yet?  May be needed one day?
 218         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 219         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 220         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 221 #endif
 222
 223         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 224         tree unknown_type_node;
 225
 226    Array type `vtable_entry_type[]'
 227
 228         tree vtbl_type_node;
 229         tree vtbl_ptr_type_node;
 230
 231    Namespaces,
 232
 233         tree std_node;
 234         tree abi_node;
 235
 236    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 237    one that the user will declare, but sufficient to be called
 238    by routines that want to abort the program.
 239
 240         tree abort_fndecl;
 241
 242    The FUNCTION_DECL for the default `::operator delete'.
 243
 244         tree global_delete_fndecl;
 245
 246    Used by RTTI
 247         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 248         tree tinfo_var_id;
 249
 250 */
 251
 252 tree cp_global_trees[CPTI_MAX];
 253
 254 /* Indicates that there is a type value in some namespace, although
 255    that is not necessarily in scope at the moment.  */
 256
 257 static tree global_type_node;
 258
 259 /* Namespace std.  */
 260 int in_std;
 261
 262 /* Expect only namespace names now. */
 263 static int only_namespace_names;
 264
 265 /* If original DECL_RESULT of current function was a register,
 266    but due to being an addressable named return value, would up
 267    on the stack, this variable holds the named return value's
 268    original location.  */
 269
 270 #define original_result_rtx cp_function_chain->x_result_rtx
 271
 272 struct named_label_list
 273 {
 274   struct binding_level *binding_level;
 275   tree names_in_scope;
 276   tree label_decl;
 277   const char *filename_o_goto;
 278   int lineno_o_goto;
 279   struct named_label_list *next;
 280 };
 281
 282 /* Used only for jumps to as-yet undefined labels, since jumps to
 283    defined labels can have their validity checked by stmt.c.  */
 284
 285 #define named_label_uses cp_function_chain->x_named_label_uses
 286
 287 /* A list of objects which have constructors or destructors
 288    which reside in the global scope.  The decl is stored in
 289    the TREE_VALUE slot and the initializer is stored
 290    in the TREE_PURPOSE slot.  */
 291 tree static_aggregates;
 292
 293 /* -- end of C++ */
 294
 295 /* A node for the integer constants 2, and 3.  */
 296
 297 tree integer_two_node, integer_three_node;
 298
 299 /* Parsing a function declarator leaves here a chain of structure
 300    and enum types declared in the parmlist.  */
 301
 302 static tree last_function_parm_tags;
 303
 304 /* Similar, for last_function_parm_tags.  */
 305 tree last_function_parms;
 306 static tree current_function_parm_tags;
 307
 308 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 309    that have names.  Here so we can clear out their names' definitions
 310    at the end of the function.  The TREE_VALUE is a LABEL_DECL; the
 311    TREE_PURPOSE is the previous binding of the label.  */
 312
 313 #define named_labels cp_function_chain->x_named_labels
 314
 315 /* Set to 0 at beginning of a function definition, and whenever
 316    a label (case or named) is defined.  Set to value of expression
 317    returned from function when that value can be transformed into
 318    a named return value.  */
 319
 320 tree current_function_return_value;
 321
 322 /* Nonzero means use the ISO C99 dialect of C.  */
 323
 324 int flag_isoc99;
 325
 326 /* Nonzero means give `double' the same size as `float'.  */
 327
 328 extern int flag_short_double;
 329
 330 /* Nonzero means don't recognize any builtin functions.  */
 331
 332 extern int flag_no_builtin;
 333
 334 /* Nonzero means don't recognize the non-ANSI builtin functions.
 335    -ansi sets this.  */
 336
 337 extern int flag_no_nonansi_builtin;
 338
 339 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
 340    objects.  */
 341 extern int flag_huge_objects;
 342
 343 /* Nonzero if we want to conserve space in the .o files.  We do this
 344    by putting uninitialized data and runtime initialized data into
 345    .common instead of .data at the expense of not flagging multiple
 346    definitions.  */
 347 extern int flag_conserve_space;
 348 \f
 349 /* C and C++ flags are in decl2.c.  */
 350
 351 /* Flag used when debugging spew.c */
 352
 353 extern int spew_debug;
 354
 355 /* A expression of value 0 with the same precision as a sizetype
 356    node, but signed.  */
 357 tree signed_size_zero_node;
 358
 359 /* The name of the anonymous namespace, throughout this translation
 360    unit.  */
 361 tree anonymous_namespace_name;
 362
 363 \f
 364 /* For each binding contour we allocate a binding_level structure
 365    which records the names defined in that contour.
 366    Contours include:
 367     0) the global one
 368     1) one for each function definition,
 369        where internal declarations of the parameters appear.
 370     2) one for each compound statement,
 371        to record its declarations.
 372
 373    The current meaning of a name can be found by searching the levels
 374    from the current one out to the global one.
 375
 376    Off to the side, may be the class_binding_level.  This exists only
 377    to catch class-local declarations.  It is otherwise nonexistent.
 378
 379    Also there may be binding levels that catch cleanups that must be
 380    run when exceptions occur.  Thus, to see whether a name is bound in
 381    the current scope, it is not enough to look in the
 382    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 383    instead.  */
 384
 385 /* Note that the information in the `names' component of the global contour
 386    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 387
 388 struct binding_level
 389   {
 390     /* A chain of _DECL nodes for all variables, constants, functions,
 391        and typedef types.  These are in the reverse of the order
 392        supplied.  There may be OVERLOADs on this list, too, but they
 393        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 394     tree names;
 395
 396     /* A list of structure, union and enum definitions, for looking up
 397        tag names.
 398        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 399        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 400        or ENUMERAL_TYPE node.
 401
 402        C++: the TREE_VALUE nodes can be simple types for
 403        component_bindings.  */
 404     tree tags;
 405
 406     /* A list of USING_DECL nodes. */
 407     tree usings;
 408
 409     /* A list of used namespaces. PURPOSE is the namespace,
 410        VALUE the common ancestor with this binding_level's namespace. */
 411     tree using_directives;
 412
 413     /* If this binding level is the binding level for a class, then
 414        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 415        is the name of an entity bound in the class; the TREE_VALUE is
 416        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 417        when leaving class scope, we can restore the
 418        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 419        the DECL bound by this name in the class.  */
 420     tree class_shadowed;
 421
 422     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 423        is used for all binding levels.  */
 424     tree type_shadowed;
 425
 426     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 427        label in this scope.  The TREE_PURPOSE is the previous value of
 428        the IDENTIFIER_LABEL VALUE.  */
 429     tree shadowed_labels;
 430
 431     /* For each level (except not the global one),
 432        a chain of BLOCK nodes for all the levels
 433        that were entered and exited one level down.  */
 434     tree blocks;
 435
 436     /* The BLOCK node for this level, if one has been preallocated.
 437        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 438     tree this_block;
 439
 440     /* The _TYPE node for this level, if parm_flag == 2.  */
 441     tree this_class;
 442
 443     /* The binding level which this one is contained in (inherits from).  */
 444     struct binding_level *level_chain;
 445
 446     /* List of decls in `names' that have incomplete
 447        structure or union types.  */
 448     tree incomplete;
 449
 450     /* List of VAR_DECLS saved from a previous for statement.
 451        These would be dead in ISO-conforming code, but might
 452        be referenced in ARM-era code.  These are stored in a
 453        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 454     tree dead_vars_from_for;
 455
 456     /* 1 for the level that holds the parameters of a function.
 457        2 for the level that holds a class declaration.  */
 458     unsigned parm_flag : 2;
 459
 460     /* 1 means make a BLOCK for this level regardless of all else.
 461        2 for temporary binding contours created by the compiler.  */
 462     unsigned keep : 2;
 463
 464     /* Nonzero if this level "doesn't exist" for tags.  */
 465     unsigned tag_transparent : 1;
 466
 467     /* Nonzero if this level can safely have additional
 468        cleanup-needing variables added to it.  */
 469     unsigned more_cleanups_ok : 1;
 470     unsigned have_cleanups : 1;
 471
 472     /* Nonzero if this scope is for storing the decls for template
 473        parameters and generic decls; these decls will be discarded and
 474        replaced with a TEMPLATE_DECL.  */
 475     unsigned template_parms_p : 1;
 476
 477     /* Nonzero if this scope corresponds to the `<>' in a
 478        `template <>' clause.  Whenever this flag is set,
 479        TEMPLATE_PARMS_P will be set as well.  */
 480     unsigned template_spec_p : 1;
 481
 482     /* This is set for a namespace binding level.  */
 483     unsigned namespace_p : 1;
 484
 485     /* True if this level is that of a for-statement where we need to
 486        worry about ambiguous (ARM or ISO) scope rules.  */
 487     unsigned is_for_scope : 1;
 488
 489     /* True if this level corresponds to an EH region, as for a try block.  */
 490     unsigned eh_region : 1;
 491
 492     /* Four bits left for this word.  */
 493
 494 #if defined(DEBUG_CP_BINDING_LEVELS)
 495     /* Binding depth at which this level began.  */
 496     unsigned binding_depth;
 497 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 498   };
 499
 500 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 501
 502 /* The binding level currently in effect.  */
 503
 504 #define current_binding_level                   \
 505   (cfun                                         \
 506    ? cp_function_chain->bindings                \
 507    : scope_chain->bindings)
 508
 509 /* The binding level of the current class, if any.  */
 510
 511 #define class_binding_level scope_chain->class_bindings
 512
 513 /* A chain of binding_level structures awaiting reuse.  */
 514
 515 static struct binding_level *free_binding_level;
 516
 517 /* The outermost binding level, for names of file scope.
 518    This is created when the compiler is started and exists
 519    through the entire run.  */
 520
 521 static struct binding_level *global_binding_level;
 522
 523 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 524
 525 static int keep_next_level_flag;
 526
 527 #if defined(DEBUG_CP_BINDING_LEVELS)
 528 static int binding_depth = 0;
 529 static int is_class_level = 0;
 530
 531 static void
 532 indent ()
 533 {
 534   register unsigned i;
 535
 536   for (i = 0; i < binding_depth*2; i++)
 537     putc (' ', stderr);
 538 }
 539 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 540
 541 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 542
 543 static void
 544 push_binding_level (newlevel, tag_transparent, keep)
 545      struct binding_level *newlevel;
 546      int tag_transparent, keep;
 547 {
 548   /* Add this level to the front of the chain (stack) of levels that
 549      are active.  */
 550   bzero ((char*) newlevel, sizeof (struct binding_level));
 551   newlevel->level_chain = current_binding_level;
 552   current_binding_level = newlevel;
 553   newlevel->tag_transparent = tag_transparent;
 554   newlevel->more_cleanups_ok = 1;
 555
 556   /* We are called before expand_start_bindings, but after
 557      expand_eh_region_start for a try block; so we check this now,
 558      before the EH block is covered up.  */
 559   newlevel->eh_region = is_eh_region ();
 560
 561   newlevel->keep = keep;
 562 #if defined(DEBUG_CP_BINDING_LEVELS)
 563   newlevel->binding_depth = binding_depth;
 564   indent ();
 565   fprintf (stderr, "push %s level 0x%08x line %d\n",
 566            (is_class_level) ? "class" : "block", newlevel, lineno);
 567   is_class_level = 0;
 568   binding_depth++;
 569 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 570 }
 571
 572 /* Find the innermost enclosing class scope, and reset
 573    CLASS_BINDING_LEVEL appropriately.  */
 574
 575 static void
 576 find_class_binding_level ()
 577 {
 578   struct binding_level *level = current_binding_level;
 579
 580   while (level && level->parm_flag != 2)
 581     level = level->level_chain;
 582   if (level && level->parm_flag == 2)
 583     class_binding_level = level;
 584   else
 585     class_binding_level = 0;
 586 }
 587
 588 static void
 589 pop_binding_level ()
 590 {
 591   if (global_binding_level)
 592     {
 593       /* Cannot pop a level, if there are none left to pop.  */
 594       if (current_binding_level == global_binding_level)
 595         my_friendly_abort (123);
 596     }
 597   /* Pop the current level, and free the structure for reuse.  */
 598 #if defined(DEBUG_CP_BINDING_LEVELS)
 599   binding_depth--;
 600   indent ();
 601   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 602           (is_class_level) ? "class" : "block",
 603           current_binding_level, lineno);
 604   if (is_class_level != (current_binding_level == class_binding_level))
 605     {
 606       indent ();
 607       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 608     }
 609   is_class_level = 0;
 610 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 611   {
 612     register struct binding_level *level = current_binding_level;
 613     current_binding_level = current_binding_level->level_chain;
 614     level->level_chain = free_binding_level;
 615 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 616     if (level->binding_depth != binding_depth)
 617       abort ();
 618 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 619     free_binding_level = level;
 620     find_class_binding_level ();
 621   }
 622 }
 623
 624 static void
 625 suspend_binding_level ()
 626 {
 627   if (class_binding_level)
 628     current_binding_level = class_binding_level;
 629
 630   if (global_binding_level)
 631     {
 632       /* Cannot suspend a level, if there are none left to suspend.  */
 633       if (current_binding_level == global_binding_level)
 634         my_friendly_abort (123);
 635     }
 636   /* Suspend the current level.  */
 637 #if defined(DEBUG_CP_BINDING_LEVELS)
 638   binding_depth--;
 639   indent ();
 640   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 641           (is_class_level) ? "class" : "block",
 642           current_binding_level, lineno);
 643   if (is_class_level != (current_binding_level == class_binding_level))
 644     {
 645       indent ();
 646       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 647     }
 648   is_class_level = 0;
 649 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 650   current_binding_level = current_binding_level->level_chain;
 651   find_class_binding_level ();
 652 }
 653
 654 static void
 655 resume_binding_level (b)
 656      struct binding_level *b;
 657 {
 658   /* Resuming binding levels is meant only for namespaces,
 659      and those cannot nest into classes. */
 660   my_friendly_assert(!class_binding_level, 386);
 661   /* Also, resuming a non-directly nested namespace is a no-no.  */
 662   my_friendly_assert(b->level_chain == current_binding_level, 386);
 663   current_binding_level = b;
 664 #if defined(DEBUG_CP_BINDING_LEVELS)
 665   b->binding_depth = binding_depth;
 666   indent ();
 667   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 668            (is_class_level) ? "class" : "block", b, lineno);
 669   is_class_level = 0;
 670   binding_depth++;
 671 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 672 }
 673 \f
 674 /* Create a new `struct binding_level'.  */
 675
 676 static
 677 struct binding_level *
 678 make_binding_level ()
 679 {
 680   /* NOSTRICT */
 681   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 682 }
 683
 684 /* Nonzero if we are currently in the global binding level.  */
 685
 686 int
 687 global_bindings_p ()
 688 {
 689   return current_binding_level == global_binding_level;
 690 }
 691
 692 /* Return the innermost binding level that is not for a class scope.  */
 693
 694 static struct binding_level *
 695 innermost_nonclass_level ()
 696 {
 697   struct binding_level *b;
 698
 699   b = current_binding_level;
 700   while (b->parm_flag == 2)
 701     b = b->level_chain;
 702
 703   return b;
 704 }
 705
 706 /* Nonzero if we are currently in a toplevel binding level.  This
 707    means either the global binding level or a namespace in a toplevel
 708    binding level.  Since there are no non-toplevel namespace levels,
 709    this really means any namespace or template parameter level.  We
 710    also include a class whose context is toplevel.  */
 711
 712 int
 713 toplevel_bindings_p ()
 714 {
 715   struct binding_level *b = innermost_nonclass_level ();
 716
 717   return b->namespace_p || b->template_parms_p;
 718 }
 719
 720 /* Nonzero if this is a namespace scope, or if we are defining a class
 721    which is itself at namespace scope, or whose enclosing class is
 722    such a class, etc.  */
 723
 724 int
 725 namespace_bindings_p ()
 726 {
 727   struct binding_level *b = innermost_nonclass_level ();
 728
 729   return b->namespace_p;
 730 }
 731
 732 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 733    unconditionally.  Otherwise, use the normal logic to decide whether
 734    or not to create a BLOCK.  */
 735
 736 void
 737 keep_next_level (keep)
 738      int keep;
 739 {
 740   keep_next_level_flag = keep;
 741 }
 742
 743 /* Nonzero if the current level needs to have a BLOCK made.  */
 744
 745 int
 746 kept_level_p ()
 747 {
 748   return (current_binding_level->blocks != NULL_TREE
 749           || current_binding_level->keep
 750           || current_binding_level->names != NULL_TREE
 751           || (current_binding_level->tags != NULL_TREE
 752               && !current_binding_level->tag_transparent));
 753 }
 754
 755 static void
 756 declare_namespace_level ()
 757 {
 758   current_binding_level->namespace_p = 1;
 759 }
 760
 761 /* Returns non-zero if this scope was created to store template
 762    parameters.  */
 763
 764 int
 765 template_parm_scope_p ()
 766 {
 767   return current_binding_level->template_parms_p;
 768 }
 769
 770 /* Returns the kind of template specialization we are currently
 771    processing, given that it's declaration contained N_CLASS_SCOPES
 772    explicit scope qualifications.  */
 773
 774 tmpl_spec_kind
 775 current_tmpl_spec_kind (n_class_scopes)
 776      int n_class_scopes;
 777 {
 778   int n_template_parm_scopes = 0;
 779   int seen_specialization_p = 0;
 780   int innermost_specialization_p = 0;
 781   struct binding_level *b;
 782
 783   /* Scan through the template parameter scopes.  */
 784   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 785     {
 786       /* If we see a specialization scope inside a parameter scope,
 787          then something is wrong.  That corresponds to a declaration
 788          like:
 789
 790             template <class T> template <> ...
 791
 792          which is always illegal since [temp.expl.spec] forbids the
 793          specialization of a class member template if the enclosing
 794          class templates are not explicitly specialized as well.  */
 795       if (b->template_spec_p)
 796         {
 797           if (n_template_parm_scopes == 0)
 798             innermost_specialization_p = 1;
 799           else
 800             seen_specialization_p = 1;
 801         }
 802       else if (seen_specialization_p == 1)
 803         return tsk_invalid_member_spec;
 804
 805       ++n_template_parm_scopes;
 806     }
 807
 808   /* Handle explicit instantiations.  */
 809   if (processing_explicit_instantiation)
 810     {
 811       if (n_template_parm_scopes != 0)
 812         /* We've seen a template parameter list during an explicit
 813            instantiation.  For example:
 814
 815              template <class T> template void f(int);
 816
 817            This is erroneous.  */
 818         return tsk_invalid_expl_inst;
 819       else
 820         return tsk_expl_inst;
 821     }
 822
 823   if (n_template_parm_scopes < n_class_scopes)
 824     /* We've not seen enough template headers to match all the
 825        specialized classes present.  For example:
 826
 827          template <class T> void R<T>::S<T>::f(int);
 828
 829        This is illegal; there needs to be one set of template
 830        parameters for each class.  */
 831     return tsk_insufficient_parms;
 832   else if (n_template_parm_scopes == n_class_scopes)
 833     /* We're processing a non-template declaration (even though it may
 834        be a member of a template class.)  For example:
 835
 836          template <class T> void S<T>::f(int);
 837
 838        The `class T' maches the `S<T>', leaving no template headers
 839        corresponding to the `f'.  */
 840     return tsk_none;
 841   else if (n_template_parm_scopes > n_class_scopes + 1)
 842     /* We've got too many template headers.  For example:
 843
 844          template <> template <class T> void f (T);
 845
 846        There need to be more enclosing classes.  */
 847     return tsk_excessive_parms;
 848   else
 849     /* This must be a template.  It's of the form:
 850
 851          template <class T> template <class U> void S<T>::f(U);
 852
 853        This is a specialization if the innermost level was a
 854        specialization; otherwise it's just a definition of the
 855        template.  */
 856     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 857 }
 858
 859 void
 860 set_class_shadows (shadows)
 861      tree shadows;
 862 {
 863   class_binding_level->class_shadowed = shadows;
 864 }
 865
 866 /* Enter a new binding level.
 867    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 868    not for that of tags.  */
 869
 870 void
 871 pushlevel (tag_transparent)
 872      int tag_transparent;
 873 {
 874   struct binding_level *newlevel;
 875
 876   if (cfun && !doing_semantic_analysis_p ())
 877     return;
 878
 879   /* Reuse or create a struct for this binding level.  */
 880 #if defined(DEBUG_CP_BINDING_LEVELS)
 881   if (0)
 882 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 883   if (free_binding_level)
 884 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 885     {
 886       newlevel = free_binding_level;
 887       free_binding_level = free_binding_level->level_chain;
 888     }
 889   else
 890     newlevel = make_binding_level ();
 891
 892   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 893   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 894   keep_next_level_flag = 0;
 895 }
 896
 897 /* Enter a new scope.  The KIND indicates what kind of scope is being
 898    created.  */
 899
 900 void
 901 begin_scope (sk)
 902      scope_kind sk;
 903 {
 904   pushlevel (0);
 905
 906   switch (sk)
 907     {
 908     case sk_template_spec:
 909       current_binding_level->template_spec_p = 1;
 910       /* Fall through.  */
 911
 912     case sk_template_parms:
 913       current_binding_level->template_parms_p = 1;
 914       break;
 915
 916     default:
 917       my_friendly_abort (20000309);
 918     }
 919 }
 920
 921 /* Exit the current scope.  */
 922
 923 void
 924 finish_scope ()
 925 {
 926   poplevel (0, 0, 0);
 927 }
 928
 929 void
 930 note_level_for_for ()
 931 {
 932   current_binding_level->is_for_scope = 1;
 933 }
 934
 935 /* For a binding between a name and an entity at a block scope,
 936    this is the `struct binding_level' for the block.  */
 937 #define BINDING_LEVEL(NODE) \
 938    (((struct tree_binding*)NODE)->scope.level)
 939
 940 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 941    level at which this declaration is being bound.  */
 942
 943 static void
 944 push_binding (id, decl, level)
 945      tree id;
 946      tree decl;
 947      struct binding_level* level;
 948 {
 949   tree binding;
 950
 951   binding = make_node (CPLUS_BINDING);
 952
 953   /* Now, fill in the binding information.  */
 954   BINDING_VALUE (binding) = decl;
 955   BINDING_TYPE (binding) = NULL_TREE;
 956   BINDING_LEVEL (binding) = level;
 957   INHERITED_VALUE_BINDING_P (binding) = 0;
 958   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 959   BINDING_HAS_LEVEL_P (binding) = 1;
 960
 961   /* And put it on the front of the list of bindings for ID.  */
 962   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 963   IDENTIFIER_BINDING (id) = binding;
 964 }
 965
 966 /* ID is already bound in the current scope.  But, DECL is an
 967    additional binding for ID in the same scope.  This is the `struct
 968    stat' hack whereby a non-typedef class-name or enum-name can be
 969    bound at the same level as some other kind of entity.  It's the
 970    responsibility of the caller to check that inserting this name is
 971    legal here.  Returns nonzero if the new binding was successful.  */
 972 static int
 973 add_binding (id, decl)
 974      tree id;
 975      tree decl;
 976 {
 977   tree binding = IDENTIFIER_BINDING (id);
 978   int ok = 1;
 979
 980   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 981     /* The new name is the type name.  */
 982     BINDING_TYPE (binding) = decl;
 983   else if (!BINDING_VALUE (binding))
 984     /* This situation arises when push_class_level_binding moves an
 985        inherited type-binding out of the way to make room for a new
 986        value binding.  */
 987     BINDING_VALUE (binding) = decl;
 988   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 989            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 990     {
 991       /* The old binding was a type name.  It was placed in
 992          BINDING_VALUE because it was thought, at the point it was
 993          declared, to be the only entity with such a name.  Move the
 994          type name into the type slot; it is now hidden by the new
 995          binding.  */
 996       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 997       BINDING_VALUE (binding) = decl;
 998       INHERITED_VALUE_BINDING_P (binding) = 0;
 999     }
1000   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1001            && TREE_CODE (decl) == TYPE_DECL
1002            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1003            && same_type_p (TREE_TYPE (decl),
1004                            TREE_TYPE (BINDING_VALUE (binding))))
1005     /* We have two typedef-names, both naming the same type to have
1006        the same name.  This is OK because of:
1007
1008          [dcl.typedef]
1009
1010          In a given scope, a typedef specifier can be used to redefine
1011          the name of any type declared in that scope to refer to the
1012          type to which it already refers.  */
1013     ok = 0;
1014   else
1015     {
1016       cp_error ("declaration of `%#D'", decl);
1017       cp_error_at ("conflicts with previous declaration `%#D'",
1018                    BINDING_VALUE (binding));
1019       ok = 0;
1020     }
1021
1022   return ok;
1023 }
1024
1025 /* Add DECL to the list of things declared in B.  */
1026
1027 static void
1028 add_decl_to_level (decl, b)
1029      tree decl;
1030      struct binding_level *b;
1031 {
1032   /* We build up the list in reverse order, and reverse it later if
1033      necessary.  */
1034   TREE_CHAIN (decl) = b->names;
1035   b->names = decl;
1036 }
1037
1038 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1039    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1040    doesn't really belong to this binding level, that it got here
1041    through a using-declaration.  */
1042
1043 void
1044 push_local_binding (id, decl, flags)
1045      tree id;
1046      tree decl;
1047      int flags;
1048 {
1049   struct binding_level *b;
1050
1051   /* Skip over any local classes.  This makes sense if we call
1052      push_local_binding with a friend decl of a local class.  */
1053   b = current_binding_level;
1054   while (b->parm_flag == 2)
1055     b = b->level_chain;
1056
1057   if (lookup_name_current_level (id))
1058     {
1059       /* Supplement the existing binding.  */
1060       if (!add_binding (id, decl))
1061         /* It didn't work.  Something else must be bound at this
1062            level.  Do not add DECL to the list of things to pop
1063            later.  */
1064         return;
1065     }
1066   else
1067     /* Create a new binding.  */
1068     push_binding (id, decl, b);
1069
1070   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1071     /* We must put the OVERLOAD into a TREE_LIST since the
1072        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1073        decls that got here through a using-declaration.  */
1074     decl = build_tree_list (NULL_TREE, decl);
1075
1076   /* And put DECL on the list of things declared by the current
1077      binding level.  */
1078   add_decl_to_level (decl, b);
1079 }
1080
1081 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1082    binding was successful.  */
1083
1084 int
1085 push_class_binding (id, decl)
1086      tree id;
1087      tree decl;
1088 {
1089   int result = 1;
1090   tree binding = IDENTIFIER_BINDING (id);
1091   tree context;
1092
1093   /* Note that we declared this value so that we can issue an error if
1094      this an illegal redeclaration of a name already used for some
1095      other purpose.  */
1096   note_name_declared_in_class (id, decl);
1097
1098   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1099     /* Supplement the existing binding.  */
1100     result = add_binding (id, decl);
1101   else
1102     /* Create a new binding.  */
1103     push_binding (id, decl, class_binding_level);
1104
1105   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1106      class-level declaration.  Note that we do not use DECL here
1107      because of the possibility of the `struct stat' hack; if DECL is
1108      a class-name or enum-name we might prefer a field-name, or some
1109      such.  */
1110   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1111
1112   /* If this is a binding from a base class, mark it as such.  */
1113   binding = IDENTIFIER_BINDING (id);
1114   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1115     {
1116       /* Any implicit typename must be from a base-class.  The
1117          context for an implicit typename declaration is always
1118          the derived class in which the lookup was done, so the checks
1119          based on the context of DECL below will not trigger.  */
1120       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1121         INHERITED_VALUE_BINDING_P (binding) = 1;
1122       else
1123         {
1124           if (TREE_CODE (decl) == OVERLOAD)
1125             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1126           else
1127             {
1128               my_friendly_assert (DECL_P (decl), 0);
1129               context = CP_DECL_CONTEXT (decl);
1130             }
1131
1132           if (is_properly_derived_from (current_class_type, context))
1133             INHERITED_VALUE_BINDING_P (binding) = 1;
1134           else
1135             INHERITED_VALUE_BINDING_P (binding) = 0;
1136         }
1137     }
1138   else if (BINDING_VALUE (binding) == decl)
1139     /* We only encounter a TREE_LIST when push_class_decls detects an
1140        ambiguity.  Such an ambiguity can be overridden by a definition
1141        in this class.  */
1142     INHERITED_VALUE_BINDING_P (binding) = 1;
1143
1144   return result;
1145 }
1146
1147 /* Remove the binding for DECL which should be the innermost binding
1148    for ID.  */
1149
1150 static void
1151 pop_binding (id, decl)
1152      tree id;
1153      tree decl;
1154 {
1155   tree binding;
1156
1157   if (id == NULL_TREE)
1158     /* It's easiest to write the loops that call this function without
1159        checking whether or not the entities involved have names.  We
1160        get here for such an entity.  */
1161     return;
1162
1163   /* Get the innermost binding for ID.  */
1164   binding = IDENTIFIER_BINDING (id);
1165
1166   /* The name should be bound.  */
1167   my_friendly_assert (binding != NULL_TREE, 0);
1168
1169   /* The DECL will be either the ordinary binding or the type
1170      binding for this identifier.  Remove that binding.  */
1171   if (BINDING_VALUE (binding) == decl)
1172     BINDING_VALUE (binding) = NULL_TREE;
1173   else if (BINDING_TYPE (binding) == decl)
1174     BINDING_TYPE (binding) = NULL_TREE;
1175   else
1176     my_friendly_abort (0);
1177
1178   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1179     /* We're completely done with the innermost binding for this
1180        identifier.  Unhook it from the list of bindings.  */
1181     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1182 }
1183
1184 /* When a label goes out of scope, check to see if that label was used
1185    in a valid manner, and issue any appropriate warnings or errors.  */
1186
1187 static void
1188 pop_label (link)
1189      tree link;
1190 {
1191   tree label = TREE_VALUE (link);
1192
1193   if (!processing_template_decl && doing_semantic_analysis_p ())
1194     {
1195       if (DECL_INITIAL (label) == NULL_TREE)
1196         {
1197           cp_error_at ("label `%D' used but not defined", label);
1198           /* Avoid crashing later.  */
1199           define_label (input_filename, 1, DECL_NAME (label));
1200         }
1201       else if (warn_unused && !TREE_USED (label))
1202         cp_warning_at ("label `%D' defined but not used", label);
1203     }
1204
1205   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), TREE_PURPOSE (link));
1206 }
1207
1208 /* At the end of a function, all labels declared within the fucntion
1209    go out of scope.  BLOCK is the top-level block for the
1210    function.  */
1211
1212 static void
1213 pop_labels (block)
1214      tree block;
1215 {
1216   tree link;
1217
1218   /* Clear out the definitions of all label names, since their scopes
1219      end here.  */
1220   for (link = named_labels; link; link = TREE_CHAIN (link))
1221     {
1222       pop_label (link);
1223       /* Put the labels into the "variables" of the top-level block,
1224          so debugger can see them.  */
1225       TREE_CHAIN (TREE_VALUE (link)) = BLOCK_VARS (block);
1226       BLOCK_VARS (block) = TREE_VALUE (link);
1227     }
1228
1229   named_labels = NULL_TREE;
1230 }
1231
1232 /* Exit a binding level.
1233    Pop the level off, and restore the state of the identifier-decl mappings
1234    that were in effect when this level was entered.
1235
1236    If KEEP == 1, this level had explicit declarations, so
1237    and create a "block" (a BLOCK node) for the level
1238    to record its declarations and subblocks for symbol table output.
1239
1240    If FUNCTIONBODY is nonzero, this level is the body of a function,
1241    so create a block as if KEEP were set and also clear out all
1242    label names.
1243
1244    If REVERSE is nonzero, reverse the order of decls before putting
1245    them into the BLOCK.  */
1246
1247 tree
1248 poplevel (keep, reverse, functionbody)
1249      int keep;
1250      int reverse;
1251      int functionbody;
1252 {
1253   register tree link;
1254   /* The chain of decls was accumulated in reverse order.
1255      Put it into forward order, just for cleanliness.  */
1256   tree decls;
1257   int tmp = functionbody;
1258   int real_functionbody;
1259   tree tags;
1260   tree subblocks;
1261   tree block = NULL_TREE;
1262   tree decl;
1263   int block_previously_created;
1264   int leaving_for_scope;
1265
1266   if (cfun && !doing_semantic_analysis_p ())
1267     return NULL_TREE;
1268
1269   my_friendly_assert (current_binding_level->parm_flag != 2,
1270                       19990916);
1271
1272   real_functionbody = (current_binding_level->keep == 2
1273                        ? ((functionbody = 0), tmp) : functionbody);
1274   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1275   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1276
1277   my_friendly_assert (!current_binding_level->class_shadowed,
1278                       19990414);
1279
1280   /* We used to use KEEP == 2 to indicate that the new block should go
1281      at the beginning of the list of blocks at this binding level,
1282      rather than the end.  This hack is no longer used.  */
1283   my_friendly_assert (keep == 0 || keep == 1, 0);
1284
1285   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1286                       (HOST_WIDE_INT) current_binding_level->level_chain,
1287                       current_binding_level->parm_flag,
1288                       current_binding_level->keep);
1289
1290   if (current_binding_level->keep == 1)
1291     keep = 1;
1292
1293   /* Get the decls in the order they were written.
1294      Usually current_binding_level->names is in reverse order.
1295      But parameter decls were previously put in forward order.  */
1296
1297   if (reverse)
1298     current_binding_level->names
1299       = decls = nreverse (current_binding_level->names);
1300   else
1301     decls = current_binding_level->names;
1302
1303   /* Output any nested inline functions within this block
1304      if they weren't already output.  */
1305   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1306     if (TREE_CODE (decl) == FUNCTION_DECL
1307         && ! TREE_ASM_WRITTEN (decl)
1308         && DECL_INITIAL (decl) != NULL_TREE
1309         && TREE_ADDRESSABLE (decl)
1310         && decl_function_context (decl) == current_function_decl)
1311       {
1312         /* If this decl was copied from a file-scope decl
1313            on account of a block-scope extern decl,
1314            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1315         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1316           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1317         else
1318           {
1319             push_function_context ();
1320             output_inline_function (decl);
1321             pop_function_context ();
1322           }
1323       }
1324
1325   /* When not in function-at-a-time mode, expand_end_bindings will
1326      warn about unused variables.  But, in function-at-a-time mode
1327      expand_end_bindings is not passed the list of variables in the
1328      current scope, and therefore no warning is emitted.  So, we
1329      explicitly warn here.  */
1330   if (!processing_template_decl)
1331     warn_about_unused_variables (getdecls ());
1332
1333   /* If there were any declarations or structure tags in that level,
1334      or if this level is a function body,
1335      create a BLOCK to record them for the life of this function.  */
1336   block = NULL_TREE;
1337   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1338   if (block_previously_created)
1339     block = current_binding_level->this_block;
1340   else if (keep == 1 || functionbody)
1341     block = make_node (BLOCK);
1342   if (block != NULL_TREE)
1343     {
1344       if (block_previously_created)
1345         {
1346           if (decls || tags || subblocks)
1347             {
1348               if (BLOCK_VARS (block))
1349                 warning ("internal compiler error: debugging info corrupted");
1350
1351               BLOCK_VARS (block) = decls;
1352
1353               /* We can have previous subblocks and new subblocks when
1354                  doing fixup_gotos with complex cleanups.  We chain the new
1355                  subblocks onto the end of any pre-existing subblocks.  */
1356               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1357                                                  subblocks);
1358             }
1359         }
1360       else
1361         {
1362           BLOCK_VARS (block) = decls;
1363           BLOCK_SUBBLOCKS (block) = subblocks;
1364         }
1365     }
1366
1367   /* In each subblock, record that this is its superior.  */
1368   if (keep >= 0)
1369     for (link = subblocks; link; link = TREE_CHAIN (link))
1370       BLOCK_SUPERCONTEXT (link) = block;
1371
1372   /* We still support the old for-scope rules, whereby the variables
1373      in a for-init statement were in scope after the for-statement
1374      ended.  We only use the new rules in flag_new_for_scope is
1375      nonzero.  */
1376   leaving_for_scope
1377     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1378
1379   /* Remove declarations for all the DECLs in this level.  */
1380   for (link = decls; link; link = TREE_CHAIN (link))
1381     {
1382       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1383         {
1384           tree outer_binding
1385             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1386           tree ns_binding;
1387
1388           if (!outer_binding)
1389             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1390           else
1391             ns_binding = NULL_TREE;
1392
1393           if (outer_binding
1394               && (BINDING_LEVEL (outer_binding)
1395                   == current_binding_level->level_chain))
1396             /* We have something like:
1397
1398                  int i;
1399                  for (int i; ;);
1400
1401                and we are leaving the `for' scope.  There's no reason to
1402                keep the binding of the inner `i' in this case.  */
1403             pop_binding (DECL_NAME (link), link);
1404           else if ((outer_binding
1405                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1406                         == TYPE_DECL))
1407                    || (ns_binding
1408                        && TREE_CODE (ns_binding) == TYPE_DECL))
1409             /* Here, we have something like:
1410
1411                  typedef int I;
1412
1413                  void f () {
1414                    for (int I; ;);
1415                  }
1416
1417                We must pop the for-scope binding so we know what's a
1418                type and what isn't.  */
1419             pop_binding (DECL_NAME (link), link);
1420           else
1421             {
1422               /* Mark this VAR_DECL as dead so that we can tell we left it
1423                  there only for backward compatibility.  */
1424               DECL_DEAD_FOR_LOCAL (link) = 1;
1425
1426               /* Keep track of what should of have happenned when we
1427                  popped the binding.  */
1428               if (outer_binding && BINDING_VALUE (outer_binding))
1429                 DECL_SHADOWED_FOR_VAR (link)
1430                   = BINDING_VALUE (outer_binding);
1431
1432               /* Add it to the list of dead variables in the next
1433                  outermost binding to that we can remove these when we
1434                  leave that binding.  */
1435               current_binding_level->level_chain->dead_vars_from_for
1436                 = tree_cons (NULL_TREE, link,
1437                              current_binding_level->level_chain->
1438                              dead_vars_from_for);
1439
1440               /* Although we don't pop the CPLUS_BINDING, we do clear
1441                  its BINDING_LEVEL since the level is going away now.  */
1442               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1443                 = 0;
1444             }
1445         }
1446       else
1447         {
1448           /* Remove the binding.  */
1449           decl = link;
1450           if (TREE_CODE (decl) == TREE_LIST)
1451             decl = TREE_VALUE (decl);
1452           if (DECL_P (decl))
1453             pop_binding (DECL_NAME (decl), decl);
1454           else if (TREE_CODE (decl) == OVERLOAD)
1455             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1456           else
1457             my_friendly_abort (0);
1458         }
1459     }
1460
1461   /* Remove declarations for any `for' variables from inner scopes
1462      that we kept around.  */
1463   for (link = current_binding_level->dead_vars_from_for;
1464        link; link = TREE_CHAIN (link))
1465     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1466
1467   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1468   for (link = current_binding_level->type_shadowed;
1469        link; link = TREE_CHAIN (link))
1470     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1471
1472   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1473   for (link = current_binding_level->shadowed_labels;
1474        link;
1475        link = TREE_CHAIN (link))
1476     pop_label (link);
1477
1478   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1479      list if a `using' declaration put them there.  The debugging
1480      back-ends won't understand OVERLOAD, so we remove them here.
1481      Because the BLOCK_VARS are (temporarily) shared with
1482      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1483      popped all the bindings.  */
1484   if (block)
1485     {
1486       tree* d;
1487
1488       for (d = &BLOCK_VARS (block); *d; )
1489         {
1490           if (TREE_CODE (*d) == TREE_LIST)
1491             *d = TREE_CHAIN (*d);
1492           else
1493             d = &TREE_CHAIN (*d);
1494         }
1495     }
1496
1497   /* If the level being exited is the top level of a function,
1498      check over all the labels.  */
1499   if (functionbody)
1500     {
1501       /* Since this is the top level block of a function, the vars are
1502          the function's parameters.  Don't leave them in the BLOCK
1503          because they are found in the FUNCTION_DECL instead.  */
1504       BLOCK_VARS (block) = 0;
1505       pop_labels (block);
1506     }
1507
1508   /* Any uses of undefined labels now operate under constraints
1509      of next binding contour.  */
1510   if (cfun)
1511     {
1512       struct binding_level *level_chain;
1513       level_chain = current_binding_level->level_chain;
1514       if (level_chain)
1515         {
1516           struct named_label_list *labels;
1517           for (labels = named_label_uses; labels; labels = labels->next)
1518             if (labels->binding_level == current_binding_level)
1519               {
1520                 labels->binding_level = level_chain;
1521                 labels->names_in_scope = level_chain->names;
1522               }
1523         }
1524     }
1525
1526   tmp = current_binding_level->keep;
1527
1528   pop_binding_level ();
1529   if (functionbody)
1530     DECL_INITIAL (current_function_decl) = block;
1531   else if (block)
1532     {
1533       if (!block_previously_created)
1534         current_binding_level->blocks
1535           = chainon (current_binding_level->blocks, block);
1536     }
1537   /* If we did not make a block for the level just exited,
1538      any blocks made for inner levels
1539      (since they cannot be recorded as subblocks in that level)
1540      must be carried forward so they will later become subblocks
1541      of something else.  */
1542   else if (subblocks)
1543     current_binding_level->blocks
1544       = chainon (current_binding_level->blocks, subblocks);
1545
1546   /* Each and every BLOCK node created here in `poplevel' is important
1547      (e.g. for proper debugging information) so if we created one
1548      earlier, mark it as "used".  */
1549   if (block)
1550     TREE_USED (block) = 1;
1551
1552   /* Take care of compiler's internal binding structures.  */
1553   if (tmp == 2)
1554     {
1555       tree scope_stmts;
1556
1557       scope_stmts
1558         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1559       if (block)
1560         {
1561           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1562           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1563         }
1564
1565       block = poplevel (keep, reverse, functionbody);
1566     }
1567
1568   return block;
1569 }
1570
1571 /* Delete the node BLOCK from the current binding level.
1572    This is used for the block inside a stmt expr ({...})
1573    so that the block can be reinserted where appropriate.  */
1574
1575 void
1576 delete_block (block)
1577      tree block;
1578 {
1579   tree t;
1580   if (current_binding_level->blocks == block)
1581     current_binding_level->blocks = TREE_CHAIN (block);
1582   for (t = current_binding_level->blocks; t;)
1583     {
1584       if (TREE_CHAIN (t) == block)
1585         TREE_CHAIN (t) = TREE_CHAIN (block);
1586       else
1587         t = TREE_CHAIN (t);
1588     }
1589   TREE_CHAIN (block) = NULL_TREE;
1590   /* Clear TREE_USED which is always set by poplevel.
1591      The flag is set again if insert_block is called.  */
1592   TREE_USED (block) = 0;
1593 }
1594
1595 /* Insert BLOCK at the end of the list of subblocks of the
1596    current binding level.  This is used when a BIND_EXPR is expanded,
1597    to handle the BLOCK node inside the BIND_EXPR.  */
1598
1599 void
1600 insert_block (block)
1601      tree block;
1602 {
1603   TREE_USED (block) = 1;
1604   current_binding_level->blocks
1605     = chainon (current_binding_level->blocks, block);
1606 }
1607
1608 /* Set the BLOCK node for the innermost scope
1609    (the one we are currently in).  */
1610
1611 void
1612 set_block (block)
1613     register tree block;
1614 {
1615   current_binding_level->this_block = block;
1616 }
1617
1618 /* Do a pushlevel for class declarations.  */
1619
1620 void
1621 pushlevel_class ()
1622 {
1623   register struct binding_level *newlevel;
1624
1625   /* Reuse or create a struct for this binding level.  */
1626 #if defined(DEBUG_CP_BINDING_LEVELS)
1627   if (0)
1628 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1629   if (free_binding_level)
1630 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1631     {
1632       newlevel = free_binding_level;
1633       free_binding_level = free_binding_level->level_chain;
1634     }
1635   else
1636     newlevel = make_binding_level ();
1637
1638 #if defined(DEBUG_CP_BINDING_LEVELS)
1639   is_class_level = 1;
1640 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1641
1642   push_binding_level (newlevel, 0, 0);
1643
1644   class_binding_level = current_binding_level;
1645   class_binding_level->parm_flag = 2;
1646   class_binding_level->this_class = current_class_type;
1647 }
1648
1649 /* ...and a poplevel for class declarations.  */
1650
1651 void
1652 poplevel_class ()
1653 {
1654   register struct binding_level *level = class_binding_level;
1655   tree shadowed;
1656
1657   my_friendly_assert (level != 0, 354);
1658
1659   /* If we're leaving a toplevel class, don't bother to do the setting
1660      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1661      shouldn't even be used when current_class_type isn't set, and second,
1662      if we don't touch it here, we're able to use the cache effect if the
1663      next time we're entering a class scope, it is the same class.  */
1664   if (current_class_depth != 1)
1665     {
1666       struct binding_level* b;
1667
1668       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1669       for (shadowed = level->class_shadowed;
1670            shadowed;
1671            shadowed = TREE_CHAIN (shadowed))
1672         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1673
1674       /* Find the next enclosing class, and recreate
1675          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1676       b = level->level_chain;
1677       while (b && b->parm_flag != 2)
1678         b = b->level_chain;
1679
1680       if (b)
1681         for (shadowed = b->class_shadowed;
1682              shadowed;
1683              shadowed = TREE_CHAIN (shadowed))
1684           {
1685             tree t;
1686
1687             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1688             while (t && BINDING_LEVEL (t) != b)
1689               t = TREE_CHAIN (t);
1690
1691             if (t)
1692               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1693                 = BINDING_VALUE (t);
1694           }
1695     }
1696   else
1697     /* Remember to save what IDENTIFIER's were bound in this scope so we
1698        can recover from cache misses.  */
1699     {
1700       previous_class_type = current_class_type;
1701       previous_class_values = class_binding_level->class_shadowed;
1702     }
1703   for (shadowed = level->type_shadowed;
1704        shadowed;
1705        shadowed = TREE_CHAIN (shadowed))
1706     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1707
1708   /* Remove the bindings for all of the class-level declarations.  */
1709   for (shadowed = level->class_shadowed;
1710        shadowed;
1711        shadowed = TREE_CHAIN (shadowed))
1712     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1713
1714   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1715                       (HOST_WIDE_INT) class_binding_level->level_chain,
1716                       class_binding_level->parm_flag,
1717                       class_binding_level->keep);
1718
1719   /* Now, pop out of the binding level which we created up in the
1720      `pushlevel_class' routine.  */
1721 #if defined(DEBUG_CP_BINDING_LEVELS)
1722   is_class_level = 1;
1723 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1724
1725   pop_binding_level ();
1726 }
1727
1728 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1729    for any names in enclosing classes.  */
1730
1731 void
1732 clear_identifier_class_values ()
1733 {
1734   tree t;
1735
1736   if (!class_binding_level)
1737     return;
1738
1739   for (t = class_binding_level->class_shadowed;
1740        t;
1741        t = TREE_CHAIN (t))
1742     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1743 }
1744
1745 /* Returns non-zero if T is a virtual function table.  */
1746
1747 int
1748 vtable_decl_p (t, data)
1749      tree t;
1750      void *data ATTRIBUTE_UNUSED;
1751 {
1752   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1753 }
1754
1755 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1756    functions.  */
1757
1758 int
1759 vtype_decl_p (t, data)
1760      tree t;
1761      void *data ATTRIBUTE_UNUSED;
1762 {
1763   return (TREE_CODE (t) == TYPE_DECL
1764           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1765           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1766 }
1767
1768 /* Return the declarations that are members of the namespace NS.  */
1769
1770 tree
1771 cp_namespace_decls (ns)
1772      tree ns;
1773 {
1774   return NAMESPACE_LEVEL (ns)->names;
1775 }
1776
1777 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1778    itself, calling F for each.  The DATA is passed to F as well.  */
1779
1780 static int
1781 walk_namespaces_r (namespace, f, data)
1782      tree namespace;
1783      walk_namespaces_fn f;
1784      void *data;
1785 {
1786   tree current;
1787   int result = 0;
1788
1789   result |= (*f) (namespace, data);
1790
1791   for (current = cp_namespace_decls (namespace);
1792        current;
1793        current = TREE_CHAIN (current))
1794     {
1795       if (TREE_CODE (current) != NAMESPACE_DECL
1796           || DECL_NAMESPACE_ALIAS (current))
1797         continue;
1798       if (!DECL_LANG_SPECIFIC (current))
1799         {
1800           /* Hmm. std. */
1801           my_friendly_assert (current == std_node, 393);
1802           continue;
1803         }
1804
1805       /* We found a namespace.  */
1806       result |= walk_namespaces_r (current, f, data);
1807     }
1808
1809   return result;
1810 }
1811
1812 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1813    F as well.  */
1814
1815 int
1816 walk_namespaces (f, data)
1817      walk_namespaces_fn f;
1818      void *data;
1819 {
1820   return walk_namespaces_r (global_namespace, f, data);
1821 }
1822
1823 struct walk_globals_data {
1824   walk_globals_pred p;
1825   walk_globals_fn f;
1826   void *data;
1827 };
1828
1829 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1830    for which P returns non-zero, call F with its address.  If any call
1831    to F returns a non-zero value, return a non-zero value.  */
1832
1833 static int
1834 walk_globals_r (namespace, data)
1835      tree namespace;
1836      void *data;
1837 {
1838   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1839   walk_globals_pred p = wgd->p;
1840   walk_globals_fn f = wgd->f;
1841   void *d = wgd->data;
1842   tree *t;
1843   int result = 0;
1844
1845   t = &NAMESPACE_LEVEL (namespace)->names;
1846
1847   while (*t)
1848     {
1849       tree glbl = *t;
1850
1851       if ((*p) (glbl, d))
1852         result |= (*f) (t, d);
1853
1854       /* If F changed *T, then *T still points at the next item to
1855          examine.  */
1856       if (*t == glbl)
1857         t = &TREE_CHAIN (*t);
1858     }
1859
1860   return result;
1861 }
1862
1863 /* Walk the global declarations.  Whenever one is found for which P
1864    returns non-zero, call F with its address.  If any call to F
1865    returns a non-zero value, return a non-zero value.  */
1866
1867 int
1868 walk_globals (p, f, data)
1869      walk_globals_pred p;
1870      walk_globals_fn f;
1871      void *data;
1872 {
1873   struct walk_globals_data wgd;
1874   wgd.p = p;
1875   wgd.f = f;
1876   wgd.data = data;
1877
1878   return walk_namespaces (walk_globals_r, &wgd);
1879 }
1880
1881 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1882    DATA is non-NULL, this is the last time we will call
1883    wrapup_global_declarations for this NAMESPACE.  */
1884
1885 int
1886 wrapup_globals_for_namespace (namespace, data)
1887      tree namespace;
1888      void *data;
1889 {
1890   tree globals = cp_namespace_decls (namespace);
1891   int len = list_length (globals);
1892   tree *vec = (tree *) alloca (sizeof (tree) * len);
1893   int i;
1894   int result;
1895   tree decl;
1896   int last_time = (data != 0);
1897
1898   if (last_time && namespace == global_namespace)
1899     /* Let compile_file handle the global namespace.  */
1900     return 0;
1901
1902   /* Process the decls in reverse order--earliest first.
1903      Put them into VEC from back to front, then take out from front.  */
1904
1905   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1906     {
1907       /* Pretend we've output an unused static variable.  This ensures
1908          that the toplevel __FUNCTION__ etc won't be emitted, unless
1909          needed. */
1910       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1911           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1912         {
1913           TREE_ASM_WRITTEN (decl) = 1;
1914           DECL_IGNORED_P (decl) = 1;
1915         }
1916       vec[len - i - 1] = decl;
1917     }
1918
1919   if (last_time)
1920     {
1921       check_global_declarations (vec, len);
1922       return 0;
1923     }
1924
1925   /* Temporarily mark vtables as external.  That prevents
1926      wrapup_global_declarations from writing them out; we must process
1927      them ourselves in finish_vtable_vardecl.  */
1928   for (i = 0; i < len; ++i)
1929     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1930       {
1931         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1932         DECL_EXTERNAL (vec[i]) = 1;
1933       }
1934
1935   /* Write out any globals that need to be output.  */
1936   result = wrapup_global_declarations (vec, len);
1937
1938   /* Undo the hack to DECL_EXTERNAL above.  */
1939   for (i = 0; i < len; ++i)
1940     if (vtable_decl_p (vec[i], /*data=*/0)
1941         && DECL_NOT_REALLY_EXTERN (vec[i]))
1942       {
1943         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1944         DECL_EXTERNAL (vec[i]) = 0;
1945       }
1946
1947   return result;
1948 }
1949
1950 \f
1951 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1952
1953 static void
1954 mark_binding_level (arg)
1955      void *arg;
1956 {
1957   struct binding_level *lvl = *(struct binding_level **)arg;
1958
1959   while (lvl)
1960     {
1961       ggc_mark_tree (lvl->names);
1962       ggc_mark_tree (lvl->tags);
1963       ggc_mark_tree (lvl->usings);
1964       ggc_mark_tree (lvl->using_directives);
1965       ggc_mark_tree (lvl->class_shadowed);
1966       ggc_mark_tree (lvl->type_shadowed);
1967       ggc_mark_tree (lvl->shadowed_labels);
1968       ggc_mark_tree (lvl->blocks);
1969       ggc_mark_tree (lvl->this_block);
1970       ggc_mark_tree (lvl->this_class);
1971       ggc_mark_tree (lvl->incomplete);
1972       ggc_mark_tree (lvl->dead_vars_from_for);
1973
1974       lvl = lvl->level_chain;
1975     }
1976 }
1977 \f
1978 /* For debugging.  */
1979 static int no_print_functions = 0;
1980 static int no_print_builtins = 0;
1981
1982 void
1983 print_binding_level (lvl)
1984      struct binding_level *lvl;
1985 {
1986   tree t;
1987   int i = 0, len;
1988   fprintf (stderr, " blocks=");
1989   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1990   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1991            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1992   if (lvl->tag_transparent)
1993     fprintf (stderr, " tag-transparent");
1994   if (lvl->more_cleanups_ok)
1995     fprintf (stderr, " more-cleanups-ok");
1996   if (lvl->have_cleanups)
1997     fprintf (stderr, " have-cleanups");
1998   fprintf (stderr, "\n");
1999   if (lvl->names)
2000     {
2001       fprintf (stderr, " names:\t");
2002       /* We can probably fit 3 names to a line?  */
2003       for (t = lvl->names; t; t = TREE_CHAIN (t))
2004         {
2005           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2006             continue;
2007           if (no_print_builtins
2008               && (TREE_CODE (t) == TYPE_DECL)
2009               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2010             continue;
2011
2012           /* Function decls tend to have longer names.  */
2013           if (TREE_CODE (t) == FUNCTION_DECL)
2014             len = 3;
2015           else
2016             len = 2;
2017           i += len;
2018           if (i > 6)
2019             {
2020               fprintf (stderr, "\n\t");
2021               i = len;
2022             }
2023           print_node_brief (stderr, "", t, 0);
2024           if (t == error_mark_node)
2025             break;
2026         }
2027       if (i)
2028         fprintf (stderr, "\n");
2029     }
2030   if (lvl->tags)
2031     {
2032       fprintf (stderr, " tags:\t");
2033       i = 0;
2034       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2035         {
2036           if (TREE_PURPOSE (t) == NULL_TREE)
2037             len = 3;
2038           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2039             len = 2;
2040           else
2041             len = 4;
2042           i += len;
2043           if (i > 5)
2044             {
2045               fprintf (stderr, "\n\t");
2046               i = len;
2047             }
2048           if (TREE_PURPOSE (t) == NULL_TREE)
2049             {
2050               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2051               fprintf (stderr, ">");
2052             }
2053           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2054             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2055           else
2056             {
2057               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2058               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2059               fprintf (stderr, ">");
2060             }
2061         }
2062       if (i)
2063         fprintf (stderr, "\n");
2064     }
2065   if (lvl->class_shadowed)
2066     {
2067       fprintf (stderr, " class-shadowed:");
2068       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2069         {
2070           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2071         }
2072       fprintf (stderr, "\n");
2073     }
2074   if (lvl->type_shadowed)
2075     {
2076       fprintf (stderr, " type-shadowed:");
2077       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2078         {
2079           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2080         }
2081       fprintf (stderr, "\n");
2082     }
2083 }
2084
2085 void
2086 print_other_binding_stack (stack)
2087      struct binding_level *stack;
2088 {
2089   struct binding_level *level;
2090   for (level = stack; level != global_binding_level; level = level->level_chain)
2091     {
2092       fprintf (stderr, "binding level ");
2093       fprintf (stderr, HOST_PTR_PRINTF, level);
2094       fprintf (stderr, "\n");
2095       print_binding_level (level);
2096     }
2097 }
2098
2099 void
2100 print_binding_stack ()
2101 {
2102   struct binding_level *b;
2103   fprintf (stderr, "current_binding_level=");
2104   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2105   fprintf (stderr, "\nclass_binding_level=");
2106   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2107   fprintf (stderr, "\nglobal_binding_level=");
2108   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2109   fprintf (stderr, "\n");
2110   if (class_binding_level)
2111     {
2112       for (b = class_binding_level; b; b = b->level_chain)
2113         if (b == current_binding_level)
2114           break;
2115       if (b)
2116         b = class_binding_level;
2117       else
2118         b = current_binding_level;
2119     }
2120   else
2121     b = current_binding_level;
2122   print_other_binding_stack (b);
2123   fprintf (stderr, "global:\n");
2124   print_binding_level (global_binding_level);
2125 }
2126
2127 /* Namespace binding access routines: The namespace_bindings field of
2128    the identifier is polymorphic, with three possible values:
2129    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2130    indicating the BINDING_VALUE of global_namespace. */
2131
2132 /* Check whether the a binding for the name to scope is known.
2133    Assumes that the bindings of the name are already a list
2134    of bindings. Returns the binding found, or NULL_TREE. */
2135
2136 static tree
2137 find_binding (name, scope)
2138      tree name;
2139      tree scope;
2140 {
2141   tree iter, prev = NULL_TREE;
2142
2143   scope = ORIGINAL_NAMESPACE (scope);
2144
2145   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2146        iter = TREE_CHAIN (iter))
2147     {
2148       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2149       if (BINDING_SCOPE (iter) == scope)
2150         {
2151           /* Move binding found to the front of the list, so
2152              subsequent lookups will find it faster. */
2153           if (prev)
2154             {
2155               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2156               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2157               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2158             }
2159           return iter;
2160         }
2161       prev = iter;
2162     }
2163   return NULL_TREE;
2164 }
2165
2166 /* Always returns a binding for name in scope. If the
2167    namespace_bindings is not a list, convert it to one first.
2168    If no binding is found, make a new one. */
2169
2170 tree
2171 binding_for_name (name, scope)
2172      tree name;
2173      tree scope;
2174 {
2175   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2176   tree result;
2177
2178   scope = ORIGINAL_NAMESPACE (scope);
2179
2180   if (b && TREE_CODE (b) != CPLUS_BINDING)
2181     {
2182       /* Get rid of optimization for global scope. */
2183       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2184       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2185       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2186     }
2187   if (b && (result = find_binding (name, scope)))
2188     return result;
2189   /* Not found, make a new one. */
2190   result = make_node (CPLUS_BINDING);
2191   TREE_CHAIN (result) = b;
2192   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2193   BINDING_SCOPE (result) = scope;
2194   BINDING_TYPE (result) = NULL_TREE;
2195   BINDING_VALUE (result) = NULL_TREE;
2196   return result;
2197 }
2198
2199 /* Return the binding value for name in scope, considering that
2200    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2201
2202 tree
2203 namespace_binding (name, scope)
2204      tree name;
2205      tree scope;
2206 {
2207   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2208   if (b == NULL_TREE)
2209     return NULL_TREE;
2210   if (scope == NULL_TREE)
2211     scope = global_namespace;
2212   if (TREE_CODE (b) != CPLUS_BINDING)
2213     return (scope == global_namespace) ? b : NULL_TREE;
2214   name = find_binding (name,scope);
2215   if (name == NULL_TREE)
2216     return name;
2217   return BINDING_VALUE (name);
2218 }
2219
2220 /* Set the binding value for name in scope. If modifying the binding
2221    of global_namespace is attempted, try to optimize it. */
2222
2223 void
2224 set_namespace_binding (name, scope, val)
2225      tree name;
2226      tree scope;
2227      tree val;
2228 {
2229   tree b;
2230
2231   if (scope == NULL_TREE)
2232     scope = global_namespace;
2233
2234   if (scope == global_namespace)
2235     {
2236       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2237       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2238         {
2239           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2240           return;
2241         }
2242     }
2243   b = binding_for_name (name, scope);
2244   BINDING_VALUE (b) = val;
2245 }
2246
2247 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2248    select a name that is unique to this compilation unit.  */
2249
2250 void
2251 push_namespace (name)
2252      tree name;
2253 {
2254   tree d = NULL_TREE;
2255   int need_new = 1;
2256   int implicit_use = 0;
2257   int global = 0;
2258   if (!global_namespace)
2259     {
2260       /* This must be ::. */
2261       my_friendly_assert (name == get_identifier ("::"), 377);
2262       global = 1;
2263     }
2264   else if (!name)
2265     {
2266       /* The name of anonymous namespace is unique for the translation
2267          unit.  */
2268       if (!anonymous_namespace_name)
2269         anonymous_namespace_name = get_file_function_name ('N');
2270       name = anonymous_namespace_name;
2271       d = IDENTIFIER_NAMESPACE_VALUE (name);
2272       if (d)
2273         /* Reopening anonymous namespace.  */
2274         need_new = 0;
2275       implicit_use = 1;
2276     }
2277   else if (current_namespace == global_namespace
2278            && name == DECL_NAME (std_node))
2279     {
2280       in_std++;
2281       return;
2282     }
2283   else
2284     {
2285       /* Check whether this is an extended namespace definition. */
2286       d = IDENTIFIER_NAMESPACE_VALUE (name);
2287       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2288         {
2289           need_new = 0;
2290           if (DECL_NAMESPACE_ALIAS (d))
2291             {
2292               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2293                         d, DECL_NAMESPACE_ALIAS (d));
2294               d = DECL_NAMESPACE_ALIAS (d);
2295             }
2296         }
2297     }
2298
2299   if (need_new)
2300     {
2301       /* Make a new namespace, binding the name to it. */
2302       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2303       /* The global namespace is not pushed, and the global binding
2304          level is set elsewhere.  */
2305       if (!global)
2306         {
2307           d = pushdecl (d);
2308           pushlevel (0);
2309           declare_namespace_level ();
2310           NAMESPACE_LEVEL (d) = current_binding_level;
2311         }
2312     }
2313   else
2314     resume_binding_level (NAMESPACE_LEVEL (d));
2315
2316   if (implicit_use)
2317     do_using_directive (d);
2318   /* Enter the name space. */
2319   current_namespace = d;
2320 }
2321
2322 /* Pop from the scope of the current namespace.  */
2323
2324 void
2325 pop_namespace ()
2326 {
2327   if (current_namespace == global_namespace)
2328     {
2329       my_friendly_assert (in_std>0, 980421);
2330       in_std--;
2331       return;
2332     }
2333   current_namespace = CP_DECL_CONTEXT (current_namespace);
2334   /* The binding level is not popped, as it might be re-opened later.  */
2335   suspend_binding_level ();
2336 }
2337
2338 /* Push into the scope of the namespace NS, even if it is deeply
2339    nested within another namespace.  */
2340
2341 void
2342 push_nested_namespace (ns)
2343      tree ns;
2344 {
2345   if (ns == global_namespace)
2346     push_to_top_level ();
2347   else
2348     {
2349       push_nested_namespace (CP_DECL_CONTEXT (ns));
2350       push_namespace (DECL_NAME (ns));
2351     }
2352 }
2353
2354 /* Pop back from the scope of the namespace NS, which was previously
2355    entered with push_nested_namespace.  */
2356
2357 void
2358 pop_nested_namespace (ns)
2359      tree ns;
2360 {
2361   while (ns != global_namespace)
2362     {
2363       pop_namespace ();
2364       ns = CP_DECL_CONTEXT (ns);
2365     }
2366
2367   pop_from_top_level ();
2368 }
2369
2370 \f
2371 /* Subroutines for reverting temporarily to top-level for instantiation
2372    of templates and such.  We actually need to clear out the class- and
2373    local-value slots of all identifiers, so that only the global values
2374    are at all visible.  Simply setting current_binding_level to the global
2375    scope isn't enough, because more binding levels may be pushed.  */
2376 struct saved_scope *scope_chain;
2377
2378 /* Mark ST for GC.  */
2379
2380 static void
2381 mark_stmt_tree (st)
2382      struct stmt_tree *st;
2383 {
2384   ggc_mark_tree (st->x_last_stmt);
2385   ggc_mark_tree (st->x_last_expr_type);
2386 }
2387
2388 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2389
2390 static void
2391 mark_saved_scope (arg)
2392      void *arg;
2393 {
2394   struct saved_scope *t = *(struct saved_scope **)arg;
2395   while (t)
2396     {
2397       mark_binding_level (&t->class_bindings);
2398       ggc_mark_tree (t->old_bindings);
2399       ggc_mark_tree (t->old_namespace);
2400       ggc_mark_tree (t->class_name);
2401       ggc_mark_tree (t->class_type);
2402       ggc_mark_tree (t->access_specifier);
2403       ggc_mark_tree (t->function_decl);
2404       if (t->lang_base)
2405         ggc_mark_tree_varray (t->lang_base);
2406       ggc_mark_tree (t->lang_name);
2407       ggc_mark_tree (t->x_function_parms);
2408       ggc_mark_tree (t->template_parms);
2409       ggc_mark_tree (t->x_previous_class_type);
2410       ggc_mark_tree (t->x_previous_class_values);
2411       ggc_mark_tree (t->x_saved_tree);
2412       ggc_mark_tree (t->incomplete);
2413       ggc_mark_tree (t->lookups);
2414
2415       mark_stmt_tree (&t->x_stmt_tree);
2416       mark_binding_level (&t->bindings);
2417       t = t->prev;
2418     }
2419 }
2420
2421 static tree
2422 store_bindings (names, old_bindings)
2423      tree names, old_bindings;
2424 {
2425   tree t;
2426   for (t = names; t; t = TREE_CHAIN (t))
2427     {
2428       tree binding, t1, id;
2429
2430       if (TREE_CODE (t) == TREE_LIST)
2431         id = TREE_PURPOSE (t);
2432       else
2433         id = DECL_NAME (t);
2434
2435       if (!id
2436           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2437              we have no IDENTIFIER_BINDING if we have left the class
2438              scope, but cached the class-level declarations.  */
2439           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2440         continue;
2441
2442       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2443         if (TREE_VEC_ELT (t1, 0) == id)
2444           goto skip_it;
2445
2446       binding = make_tree_vec (4);
2447
2448       if (id)
2449         {
2450           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2451           TREE_VEC_ELT (binding, 0) = id;
2452           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2453           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2454           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2455           IDENTIFIER_BINDING (id) = NULL_TREE;
2456           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2457         }
2458       TREE_CHAIN (binding) = old_bindings;
2459       old_bindings = binding;
2460     skip_it:
2461       ;
2462     }
2463   return old_bindings;
2464 }
2465
2466 void
2467 maybe_push_to_top_level (pseudo)
2468      int pseudo;
2469 {
2470   struct saved_scope *s;
2471   struct binding_level *b;
2472   tree old_bindings;
2473   int need_pop;
2474
2475   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2476
2477   b = scope_chain ? current_binding_level : 0;
2478
2479   /* If we're in the middle of some function, save our state.  */
2480   if (cfun)
2481     {
2482       need_pop = 1;
2483       push_function_context_to (NULL_TREE);
2484     }
2485   else
2486     need_pop = 0;
2487
2488   old_bindings = NULL_TREE;
2489   if (scope_chain && previous_class_type)
2490     old_bindings = store_bindings (previous_class_values, old_bindings);
2491
2492   /* Have to include global_binding_level, because class-level decls
2493      aren't listed anywhere useful.  */
2494   for (; b; b = b->level_chain)
2495     {
2496       tree t;
2497
2498       /* Template IDs are inserted into the global level. If they were
2499          inserted into namespace level, finish_file wouldn't find them
2500          when doing pending instantiations. Therefore, don't stop at
2501          namespace level, but continue until :: .  */
2502       if (b == global_binding_level || (pseudo && b->template_parms_p))
2503         break;
2504
2505       old_bindings = store_bindings (b->names, old_bindings);
2506       /* We also need to check class_shadowed to save class-level type
2507          bindings, since pushclass doesn't fill in b->names.  */
2508       if (b->parm_flag == 2)
2509         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2510
2511       /* Unwind type-value slots back to top level.  */
2512       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2513         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2514     }
2515   s->prev = scope_chain;
2516   s->old_bindings = old_bindings;
2517   s->bindings = b;
2518   s->need_pop_function_context = need_pop;
2519   s->function_decl = current_function_decl;
2520
2521   scope_chain = s;
2522   current_function_decl = NULL_TREE;
2523   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2524   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2525   current_lang_name = lang_name_cplusplus;
2526   strict_prototype = strict_prototypes_lang_cplusplus;
2527   current_namespace = global_namespace;
2528 }
2529
2530 void
2531 push_to_top_level ()
2532 {
2533   maybe_push_to_top_level (0);
2534 }
2535
2536 void
2537 pop_from_top_level ()
2538 {
2539   struct saved_scope *s = scope_chain;
2540   tree t;
2541
2542   /* Clear out class-level bindings cache.  */
2543   if (previous_class_type)
2544     invalidate_class_lookup_cache ();
2545
2546   VARRAY_FREE (current_lang_base);
2547
2548   scope_chain = s->prev;
2549   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2550     {
2551       tree id = TREE_VEC_ELT (t, 0);
2552       if (id)
2553         {
2554           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2555           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2556           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2557         }
2558     }
2559
2560   if (current_lang_name == lang_name_cplusplus)
2561     strict_prototype = strict_prototypes_lang_cplusplus;
2562   else if (current_lang_name == lang_name_c)
2563     strict_prototype = strict_prototypes_lang_c;
2564
2565   /* If we were in the middle of compiling a function, restore our
2566      state.  */
2567   if (s->need_pop_function_context)
2568     pop_function_context_from (NULL_TREE);
2569   current_function_decl = s->function_decl;
2570
2571   free (s);
2572 }
2573 \f
2574 /* Push a definition of struct, union or enum tag "name".
2575    into binding_level "b".   "type" should be the type node,
2576    We assume that the tag "name" is not already defined.
2577
2578    Note that the definition may really be just a forward reference.
2579    In that case, the TYPE_SIZE will be a NULL_TREE.
2580
2581    C++ gratuitously puts all these tags in the name space.  */
2582
2583 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2584    record the shadowed value for this binding contour.  TYPE is
2585    the type that ID maps to.  */
2586
2587 static void
2588 set_identifier_type_value_with_scope (id, type, b)
2589      tree id;
2590      tree type;
2591      struct binding_level *b;
2592 {
2593   if (!b->namespace_p)
2594     {
2595       /* Shadow the marker, not the real thing, so that the marker
2596          gets restored later. */
2597       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2598       b->type_shadowed
2599         = tree_cons (id, old_type_value, b->type_shadowed);
2600     }
2601   else
2602     {
2603       tree binding = binding_for_name (id, current_namespace);
2604       BINDING_TYPE (binding) = type;
2605       /* Store marker instead of real type. */
2606       type = global_type_node;
2607     }
2608   SET_IDENTIFIER_TYPE_VALUE (id, type);
2609 }
2610
2611 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2612
2613 void
2614 set_identifier_type_value (id, type)
2615      tree id;
2616      tree type;
2617 {
2618   set_identifier_type_value_with_scope (id, type, current_binding_level);
2619 }
2620
2621 /* Return the type associated with id. */
2622
2623 tree
2624 identifier_type_value (id)
2625      tree id;
2626 {
2627   /* There is no type with that name, anywhere. */
2628   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2629     return NULL_TREE;
2630   /* This is not the type marker, but the real thing. */
2631   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2632     return REAL_IDENTIFIER_TYPE_VALUE (id);
2633   /* Have to search for it. It must be on the global level, now.
2634      Ask lookup_name not to return non-types. */
2635   id = lookup_name_real (id, 2, 1, 0);
2636   if (id)
2637     return TREE_TYPE (id);
2638   return NULL_TREE;
2639 }
2640
2641 /* Pop off extraneous binding levels left over due to syntax errors.
2642
2643    We don't pop past namespaces, as they might be valid.  */
2644
2645 void
2646 pop_everything ()
2647 {
2648 #ifdef DEBUG_CP_BINDING_LEVELS
2649   fprintf (stderr, "XXX entering pop_everything ()\n");
2650 #endif
2651   while (!toplevel_bindings_p ())
2652     {
2653       if (current_binding_level->parm_flag == 2)
2654         pop_nested_class ();
2655       else
2656         poplevel (0, 0, 0);
2657     }
2658 #ifdef DEBUG_CP_BINDING_LEVELS
2659   fprintf (stderr, "XXX leaving pop_everything ()\n");
2660 #endif
2661 }
2662
2663 /* The type TYPE is being declared.  If it is a class template, or a
2664    specialization of a class template, do any processing required and
2665    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2666    being declared a friend.  B is the binding level at which this TYPE
2667    should be bound.
2668
2669    Returns the TYPE_DECL for TYPE, which may have been altered by this
2670    processing.  */
2671
2672 static tree
2673 maybe_process_template_type_declaration (type, globalize, b)
2674      tree type;
2675      int globalize;
2676      struct binding_level* b;
2677 {
2678   tree decl = TYPE_NAME (type);
2679
2680   if (processing_template_parmlist)
2681     /* You can't declare a new template type in a template parameter
2682        list.  But, you can declare a non-template type:
2683
2684          template <class A*> struct S;
2685
2686        is a forward-declaration of `A'.  */
2687     ;
2688   else
2689     {
2690       maybe_check_template_type (type);
2691
2692       my_friendly_assert (IS_AGGR_TYPE (type)
2693                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2694
2695
2696       if (processing_template_decl)
2697         {
2698           /* This may change after the call to
2699              push_template_decl_real, but we want the original value.  */
2700           tree name = DECL_NAME (decl);
2701
2702           decl = push_template_decl_real (decl, globalize);
2703           /* If the current binding level is the binding level for the
2704              template parameters (see the comment in
2705              begin_template_parm_list) and the enclosing level is a class
2706              scope, and we're not looking at a friend, push the
2707              declaration of the member class into the class scope.  In the
2708              friend case, push_template_decl will already have put the
2709              friend into global scope, if appropriate.  */
2710           if (TREE_CODE (type) != ENUMERAL_TYPE
2711               && !globalize && b->template_parms_p
2712               && b->level_chain->parm_flag == 2)
2713             {
2714               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2715               /* Put this tag on the list of tags for the class, since
2716                  that won't happen below because B is not the class
2717                  binding level, but is instead the pseudo-global level.  */
2718               b->level_chain->tags =
2719                 tree_cons (name, type, b->level_chain->tags);
2720               if (!COMPLETE_TYPE_P (current_class_type))
2721                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2722             }
2723         }
2724     }
2725
2726   return decl;
2727 }
2728
2729 /* In C++, you don't have to write `struct S' to refer to `S'; you
2730    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2731    if the user had written `typedef struct S S'.  Create and return
2732    the TYPE_DECL for TYPE.  */
2733
2734 tree
2735 create_implicit_typedef (name, type)
2736      tree name;
2737      tree type;
2738 {
2739   tree decl;
2740
2741   decl = build_decl (TYPE_DECL, name, type);
2742   SET_DECL_ARTIFICIAL (decl);
2743   /* There are other implicit type declarations, like the one *within*
2744      a class that allows you to write `S::S'.  We must distinguish
2745      amongst these.  */
2746   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2747   TYPE_NAME (type) = decl;
2748
2749   return decl;
2750 }
2751
2752 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2753    Normally put it into the inner-most non-tag-transparent scope,
2754    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2755    The latter is needed for implicit declarations.  */
2756
2757 void
2758 pushtag (name, type, globalize)
2759      tree name, type;
2760      int globalize;
2761 {
2762   register struct binding_level *b;
2763
2764   b = current_binding_level;
2765   while (b->tag_transparent
2766          || (globalize && b->parm_flag == 2))
2767     b = b->level_chain;
2768
2769   b->tags = tree_cons (name, type, b->tags);
2770
2771   if (name)
2772     {
2773       /* Do C++ gratuitous typedefing.  */
2774       if (IDENTIFIER_TYPE_VALUE (name) != type)
2775         {
2776           register tree d = NULL_TREE;
2777           int in_class = 0;
2778           tree context = TYPE_CONTEXT (type);
2779
2780           if (! context)
2781             {
2782               tree cs = current_scope ();
2783
2784               if (! globalize)
2785                 context = cs;
2786               else if (cs != NULL_TREE && TYPE_P (cs))
2787                 /* When declaring a friend class of a local class, we want
2788                    to inject the newly named class into the scope
2789                    containing the local class, not the namespace scope.  */
2790                 context = decl_function_context (get_type_decl (cs));
2791             }
2792           if (!context)
2793             context = current_namespace;
2794
2795           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2796               || b->parm_flag == 2)
2797             in_class = 1;
2798
2799           if (current_lang_name == lang_name_java)
2800             TYPE_FOR_JAVA (type) = 1;
2801
2802           d = create_implicit_typedef (name, type);
2803           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2804           if (! in_class)
2805             set_identifier_type_value_with_scope (name, type, b);
2806
2807           d = maybe_process_template_type_declaration (type,
2808                                                        globalize, b);
2809
2810           if (b->parm_flag == 2)
2811             {
2812               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2813                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2814                    class.  But if it's a member template class, we
2815                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2816                    is done later.  */
2817                 finish_member_declaration (d);
2818               else
2819                 pushdecl_class_level (d);
2820             }
2821           else
2822             d = pushdecl_with_scope (d, b);
2823
2824           if (ANON_AGGRNAME_P (name))
2825             DECL_IGNORED_P (d) = 1;
2826
2827           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2828           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2829           if (!uses_template_parms (type))
2830             DECL_ASSEMBLER_NAME (d)
2831               = get_identifier (build_overload_name (type, 1, 1));
2832         }
2833       if (b->parm_flag == 2)
2834         {
2835           if (!COMPLETE_TYPE_P (current_class_type))
2836             CLASSTYPE_TAGS (current_class_type) = b->tags;
2837         }
2838     }
2839
2840   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2841     /* Use the canonical TYPE_DECL for this node.  */
2842     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2843   else
2844     {
2845       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2846          will be the tagged type we just added to the current
2847          binding level.  This fake NULL-named TYPE_DECL node helps
2848          dwarfout.c to know when it needs to output a
2849          representation of a tagged type, and it also gives us a
2850          convenient place to record the "scope start" address for
2851          the tagged type.  */
2852
2853       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2854       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2855     }
2856 }
2857
2858 /* Counter used to create anonymous type names.  */
2859
2860 static int anon_cnt = 0;
2861
2862 /* Return an IDENTIFIER which can be used as a name for
2863    anonymous structs and unions.  */
2864
2865 tree
2866 make_anon_name ()
2867 {
2868   char buf[32];
2869
2870   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2871   return get_identifier (buf);
2872 }
2873
2874 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2875    This keeps dbxout from getting confused.  */
2876
2877 void
2878 clear_anon_tags ()
2879 {
2880   register struct binding_level *b;
2881   register tree tags;
2882   static int last_cnt = 0;
2883
2884   /* Fast out if no new anon names were declared.  */
2885   if (last_cnt == anon_cnt)
2886     return;
2887
2888   b = current_binding_level;
2889   while (b->tag_transparent)
2890     b = b->level_chain;
2891   tags = b->tags;
2892   while (tags)
2893     {
2894       /* A NULL purpose means we have already processed all tags
2895          from here to the end of the list.  */
2896       if (TREE_PURPOSE (tags) == NULL_TREE)
2897         break;
2898       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2899         TREE_PURPOSE (tags) = NULL_TREE;
2900       tags = TREE_CHAIN (tags);
2901     }
2902   last_cnt = anon_cnt;
2903 }
2904 \f
2905 /* Subroutine of duplicate_decls: return truthvalue of whether
2906    or not types of these decls match.
2907
2908    For C++, we must compare the parameter list so that `int' can match
2909    `int&' in a parameter position, but `int&' is not confused with
2910    `const int&'.  */
2911
2912 int
2913 decls_match (newdecl, olddecl)
2914      tree newdecl, olddecl;
2915 {
2916   int types_match;
2917
2918   if (newdecl == olddecl)
2919     return 1;
2920
2921   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2922     /* If the two DECLs are not even the same kind of thing, we're not
2923        interested in their types.  */
2924     return 0;
2925
2926   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2927     {
2928       tree f1 = TREE_TYPE (newdecl);
2929       tree f2 = TREE_TYPE (olddecl);
2930       tree p1 = TYPE_ARG_TYPES (f1);
2931       tree p2 = TYPE_ARG_TYPES (f2);
2932
2933       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2934           && ! (DECL_LANGUAGE (newdecl) == lang_c
2935                 && DECL_LANGUAGE (olddecl) == lang_c))
2936         return 0;
2937
2938       if (TREE_CODE (f1) != TREE_CODE (f2))
2939         return 0;
2940
2941       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2942         {
2943           if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2944               && p2 == NULL_TREE)
2945             {
2946               types_match = self_promoting_args_p (p1);
2947               if (p1 == void_list_node)
2948                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2949             }
2950           else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2951                    && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2952             {
2953               types_match = self_promoting_args_p (p2);
2954               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2955             }
2956           else
2957             types_match = compparms (p1, p2);
2958         }
2959       else
2960         types_match = 0;
2961     }
2962   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2963     {
2964       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2965                                 DECL_TEMPLATE_PARMS (olddecl)))
2966         return 0;
2967
2968       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2969         types_match = 1;
2970       else
2971         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2972                                    DECL_TEMPLATE_RESULT (newdecl));
2973     }
2974   else
2975     {
2976       if (TREE_TYPE (newdecl) == error_mark_node)
2977         types_match = TREE_TYPE (olddecl) == error_mark_node;
2978       else if (TREE_TYPE (olddecl) == NULL_TREE)
2979         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2980       else if (TREE_TYPE (newdecl) == NULL_TREE)
2981         types_match = 0;
2982       else
2983         types_match = comptypes (TREE_TYPE (newdecl),
2984                                  TREE_TYPE (olddecl),
2985                                  COMPARE_REDECLARATION);
2986     }
2987
2988   return types_match;
2989 }
2990
2991 /* If NEWDECL is `static' and an `extern' was seen previously,
2992    warn about it.  OLDDECL is the previous declaration.
2993
2994    Note that this does not apply to the C++ case of declaring
2995    a variable `extern const' and then later `const'.
2996
2997    Don't complain about built-in functions, since they are beyond
2998    the user's control.  */
2999
3000 static void
3001 warn_extern_redeclared_static (newdecl, olddecl)
3002      tree newdecl, olddecl;
3003 {
3004   static const char *explicit_extern_static_warning
3005     = "`%D' was declared `extern' and later `static'";
3006   static const char *implicit_extern_static_warning
3007     = "`%D' was declared implicitly `extern' and later `static'";
3008
3009   tree name;
3010
3011   if (TREE_CODE (newdecl) == TYPE_DECL
3012       || TREE_CODE (newdecl) == TEMPLATE_DECL)
3013     return;
3014
3015   /* Don't get confused by static member functions; that's a different
3016      use of `static'.  */
3017   if (TREE_CODE (newdecl) == FUNCTION_DECL
3018       && DECL_STATIC_FUNCTION_P (newdecl))
3019     return;
3020
3021   /* If the old declaration was `static', or the new one isn't, then
3022      then everything is OK.  */
3023   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3024     return;
3025
3026   /* It's OK to declare a builtin function as `static'.  */
3027   if (TREE_CODE (olddecl) == FUNCTION_DECL
3028       && DECL_ARTIFICIAL (olddecl))
3029     return;
3030
3031   name = DECL_ASSEMBLER_NAME (newdecl);
3032   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3033               ? implicit_extern_static_warning
3034               : explicit_extern_static_warning, newdecl);
3035   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3036 }
3037
3038 /* Handle when a new declaration NEWDECL has the same name as an old
3039    one OLDDECL in the same binding contour.  Prints an error message
3040    if appropriate.
3041
3042    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3043    Otherwise, return 0.  */
3044
3045 int
3046 duplicate_decls (newdecl, olddecl)
3047      tree newdecl, olddecl;
3048 {
3049   unsigned olddecl_uid = DECL_UID (olddecl);
3050   int olddecl_friend = 0, types_match = 0;
3051   int new_defines_function = 0;
3052
3053   if (newdecl == olddecl)
3054     return 1;
3055
3056   types_match = decls_match (newdecl, olddecl);
3057
3058   /* If either the type of the new decl or the type of the old decl is an
3059      error_mark_node, then that implies that we have already issued an
3060      error (earlier) for some bogus type specification, and in that case,
3061      it is rather pointless to harass the user with yet more error message
3062      about the same declaration, so just pretend the types match here.  */
3063   if (TREE_TYPE (newdecl) == error_mark_node
3064       || TREE_TYPE (olddecl) == error_mark_node)
3065     types_match = 1;
3066
3067   /* Check for redeclaration and other discrepancies. */
3068   if (TREE_CODE (olddecl) == FUNCTION_DECL
3069       && DECL_ARTIFICIAL (olddecl))
3070     {
3071       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3072         {
3073           /* If you declare a built-in or predefined function name as static,
3074              the old definition is overridden, but optionally warn this was a
3075              bad choice of name.  */
3076           if (! TREE_PUBLIC (newdecl))
3077             {
3078               if (warn_shadow)
3079                 cp_warning ("shadowing %s function `%#D'",
3080                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3081                             olddecl);
3082               /* Discard the old built-in function.  */
3083               return 0;
3084             }
3085           /* If the built-in is not ansi, then programs can override
3086              it even globally without an error.  */
3087           else if (! DECL_BUILT_IN (olddecl))
3088             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3089                         olddecl, newdecl);
3090           else
3091             {
3092               cp_error ("declaration of `%#D'", newdecl);
3093               cp_error ("conflicts with built-in declaration `%#D'",
3094                         olddecl);
3095             }
3096           return 0;
3097         }
3098       else if (!types_match)
3099         {
3100           if ((DECL_LANGUAGE (newdecl) == lang_c
3101                && DECL_LANGUAGE (olddecl) == lang_c)
3102               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3103                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3104             {
3105               /* A near match; override the builtin.  */
3106
3107               if (TREE_PUBLIC (newdecl))
3108                 {
3109                   cp_warning ("new declaration `%#D'", newdecl);
3110                   cp_warning ("ambiguates built-in declaration `%#D'",
3111                               olddecl);
3112                 }
3113               else if (warn_shadow)
3114                 cp_warning ("shadowing %s function `%#D'",
3115                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3116                             olddecl);
3117             }
3118           else
3119             /* Discard the old built-in function.  */
3120             return 0;
3121         }
3122
3123       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3124         {
3125           /* If a builtin function is redeclared as `static', merge
3126              the declarations, but make the original one static.  */
3127           DECL_THIS_STATIC (olddecl) = 1;
3128           TREE_PUBLIC (olddecl) = 0;
3129
3130           /* Make the olddeclaration consistent with the new one so that
3131              all remnants of the builtin-ness of this function will be
3132              banished.  */
3133           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3134           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3135           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3136           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3137                                        newdecl);
3138         }
3139     }
3140   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3141     {
3142       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3143            && TREE_CODE (newdecl) != TYPE_DECL
3144            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3145                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3146           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3147               && TREE_CODE (olddecl) != TYPE_DECL
3148               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3149                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3150                         == TYPE_DECL))))
3151         {
3152           /* We do nothing special here, because C++ does such nasty
3153              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3154              get shadowed, and know that if we need to find a TYPE_DECL
3155              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3156              slot of the identifier.  */
3157           return 0;
3158         }
3159
3160       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3161            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3162           || (TREE_CODE (olddecl) == FUNCTION_DECL
3163               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3164         return 0;
3165
3166       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3167       if (TREE_CODE (olddecl) == TREE_LIST)
3168         olddecl = TREE_VALUE (olddecl);
3169       cp_error_at ("previous declaration of `%#D'", olddecl);
3170
3171       /* New decl is completely inconsistent with the old one =>
3172          tell caller to replace the old one.  */
3173
3174       return 0;
3175     }
3176   else if (!types_match)
3177     {
3178       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3179         /* These are certainly not duplicate declarations; they're
3180            from different scopes.  */
3181         return 0;
3182
3183       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3184         {
3185           /* The name of a class template may not be declared to refer to
3186              any other template, class, function, object, namespace, value,
3187              or type in the same scope.  */
3188           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3189               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3190             {
3191               cp_error ("declaration of template `%#D'", newdecl);
3192               cp_error_at ("conflicts with previous declaration `%#D'",
3193                            olddecl);
3194             }
3195           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3196                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3197                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3198                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3199                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3200                                            DECL_TEMPLATE_PARMS (olddecl)))
3201             {
3202               cp_error ("new declaration `%#D'", newdecl);
3203               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3204             }
3205           return 0;
3206         }
3207       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3208         {
3209           if (DECL_LANGUAGE (newdecl) == lang_c
3210               && DECL_LANGUAGE (olddecl) == lang_c)
3211             {
3212               cp_error ("declaration of C function `%#D' conflicts with",
3213                         newdecl);
3214               cp_error_at ("previous declaration `%#D' here", olddecl);
3215             }
3216           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3217                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3218             {
3219               cp_error ("new declaration `%#D'", newdecl);
3220               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3221             }
3222           else
3223             return 0;
3224         }
3225
3226       /* Already complained about this, so don't do so again.  */
3227       else if (current_class_type == NULL_TREE
3228           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3229         {
3230           cp_error ("conflicting types for `%#D'", newdecl);
3231           cp_error_at ("previous declaration as `%#D'", olddecl);
3232         }
3233     }
3234   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3235             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3236                  && (!DECL_TEMPLATE_INFO (newdecl)
3237                      || (DECL_TI_TEMPLATE (newdecl)
3238                          != DECL_TI_TEMPLATE (olddecl))))
3239                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3240                     && (!DECL_TEMPLATE_INFO (olddecl)
3241                         || (DECL_TI_TEMPLATE (olddecl)
3242                             != DECL_TI_TEMPLATE (newdecl))))))
3243     /* It's OK to have a template specialization and a non-template
3244        with the same type, or to have specializations of two
3245        different templates with the same type.  Note that if one is a
3246        specialization, and the other is an instantiation of the same
3247        template, that we do not exit at this point.  That situation
3248        can occur if we instantiate a template class, and then
3249        specialize one of its methods.  This situation is legal, but
3250        the declarations must be merged in the usual way.  */
3251     return 0;
3252   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3253            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3254                 && !DECL_USE_TEMPLATE (newdecl))
3255                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3256                    && !DECL_USE_TEMPLATE (olddecl))))
3257     /* One of the declarations is a template instantiation, and the
3258        other is not a template at all.  That's OK.  */
3259     return 0;
3260   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3261            && DECL_NAMESPACE_ALIAS (newdecl)
3262            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3263     /* Redeclaration of namespace alias, ignore it. */
3264     return 1;
3265   else
3266     {
3267       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3268       if (errmsg)
3269         {
3270           cp_error (errmsg, newdecl);
3271           if (DECL_NAME (olddecl) != NULL_TREE)
3272             cp_error_at ((DECL_INITIAL (olddecl)
3273                           && namespace_bindings_p ())
3274                          ? "`%#D' previously defined here"
3275                          : "`%#D' previously declared here", olddecl);
3276         }
3277       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3278                && DECL_INITIAL (olddecl) != NULL_TREE
3279                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3280                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3281         {
3282           /* Prototype decl follows defn w/o prototype.  */
3283           cp_warning_at ("prototype for `%#D'", newdecl);
3284           cp_warning_at ("follows non-prototype definition here", olddecl);
3285         }
3286       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3287                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3288         {
3289           /* extern "C" int foo ();
3290              int foo () { bar (); }
3291              is OK.  */
3292           if (current_lang_stack
3293               == &VARRAY_TREE (current_lang_base, 0))
3294             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3295           else
3296             {
3297               cp_error_at ("previous declaration of `%#D' with %L linkage",
3298                            olddecl, DECL_LANGUAGE (olddecl));
3299               cp_error ("conflicts with new declaration with %L linkage",
3300                         DECL_LANGUAGE (newdecl));
3301             }
3302         }
3303
3304       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3305         ;
3306       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3307         {
3308           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3309           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3310           int i = 1;
3311
3312           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3313             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3314
3315           for (; t1 && t1 != void_list_node;
3316                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3317             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3318               {
3319                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3320                                            TREE_PURPOSE (t2)))
3321                   {
3322                     if (pedantic)
3323                       {
3324                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3325                                     i, newdecl);
3326                         cp_pedwarn_at ("after previous specification in `%#D'",
3327                                        olddecl);
3328                       }
3329                   }
3330                 else
3331                   {
3332                     cp_error ("default argument given for parameter %d of `%#D'",
3333                               i, newdecl);
3334                     cp_error_at ("after previous specification in `%#D'",
3335                                  olddecl);
3336                   }
3337               }
3338
3339           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3340               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3341             {
3342               cp_warning ("`%#D' was used before it was declared inline",
3343                           newdecl);
3344               cp_warning_at ("previous non-inline declaration here",
3345                              olddecl);
3346             }
3347         }
3348     }
3349
3350   /* If new decl is `static' and an `extern' was seen previously,
3351      warn about it.  */
3352   warn_extern_redeclared_static (newdecl, olddecl);
3353
3354   /* We have committed to returning 1 at this point.  */
3355   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3356     {
3357       /* Now that functions must hold information normally held
3358          by field decls, there is extra work to do so that
3359          declaration information does not get destroyed during
3360          definition.  */
3361       if (DECL_VINDEX (olddecl))
3362         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3363       if (DECL_VIRTUAL_CONTEXT (olddecl))
3364         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3365       if (DECL_CONTEXT (olddecl))
3366         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3367       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3368         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3369       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3370       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3371       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3372       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3373       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3374       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3375       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3376
3377       /* Optionally warn about more than one declaration for the same
3378          name, but don't warn about a function declaration followed by a
3379          definition.  */
3380       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3381           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3382           /* Don't warn about extern decl followed by definition. */
3383           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3384           /* Don't warn about friends, let add_friend take care of it. */
3385           && ! DECL_FRIEND_P (newdecl))
3386         {
3387           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3388           cp_warning_at ("previous declaration of `%D'", olddecl);
3389         }
3390     }
3391
3392   /* Deal with C++: must preserve virtual function table size.  */
3393   if (TREE_CODE (olddecl) == TYPE_DECL)
3394     {
3395       register tree newtype = TREE_TYPE (newdecl);
3396       register tree oldtype = TREE_TYPE (olddecl);
3397
3398       if (newtype != error_mark_node && oldtype != error_mark_node
3399           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3400         {
3401           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3402           CLASSTYPE_FRIEND_CLASSES (newtype)
3403             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3404         }
3405     }
3406
3407   /* Copy all the DECL_... slots specified in the new decl
3408      except for any that we copy here from the old type.  */
3409   DECL_MACHINE_ATTRIBUTES (newdecl)
3410     = merge_machine_decl_attributes (olddecl, newdecl);
3411
3412   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3413     {
3414       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3415                              DECL_TEMPLATE_RESULT (olddecl)))
3416         cp_error ("invalid redeclaration of %D", newdecl);
3417       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3418       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3419         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3420                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3421
3422       return 1;
3423     }
3424
3425   if (types_match)
3426     {
3427       /* Automatically handles default parameters.  */
3428       tree oldtype = TREE_TYPE (olddecl);
3429       tree newtype;
3430
3431       /* Merge the data types specified in the two decls.  */
3432       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3433
3434       if (TREE_CODE (newdecl) == VAR_DECL)
3435         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3436       /* Do this after calling `common_type' so that default
3437          parameters don't confuse us.  */
3438       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3439           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3440               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3441         {
3442           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3443                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3444           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3445                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3446
3447           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3448               && DECL_SOURCE_LINE (olddecl) != 0
3449               && flag_exceptions
3450               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3451                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3452             {
3453               cp_error ("declaration of `%F' throws different exceptions",
3454                         newdecl);
3455               cp_error_at ("than previous declaration `%F'", olddecl);
3456             }
3457         }
3458       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3459
3460       /* Lay the type out, unless already done.  */
3461       if (! same_type_p (newtype, oldtype)
3462           && TREE_TYPE (newdecl) != error_mark_node
3463           && !(processing_template_decl && uses_template_parms (newdecl)))
3464         layout_type (TREE_TYPE (newdecl));
3465
3466       if ((TREE_CODE (newdecl) == VAR_DECL
3467            || TREE_CODE (newdecl) == PARM_DECL
3468            || TREE_CODE (newdecl) == RESULT_DECL
3469            || TREE_CODE (newdecl) == FIELD_DECL
3470            || TREE_CODE (newdecl) == TYPE_DECL)
3471           && !(processing_template_decl && uses_template_parms (newdecl)))
3472         layout_decl (newdecl, 0);
3473
3474       /* Merge the type qualifiers.  */
3475       if (TREE_READONLY (newdecl))
3476         TREE_READONLY (olddecl) = 1;
3477       if (TREE_THIS_VOLATILE (newdecl))
3478         TREE_THIS_VOLATILE (olddecl) = 1;
3479
3480       /* Merge the initialization information.  */
3481       if (DECL_INITIAL (newdecl) == NULL_TREE
3482           && DECL_INITIAL (olddecl) != NULL_TREE)
3483         {
3484           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3485           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3486           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3487           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3488               && DECL_LANG_SPECIFIC (newdecl)
3489               && DECL_LANG_SPECIFIC (olddecl))
3490             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3491         }
3492
3493       /* Merge the section attribute.
3494          We want to issue an error if the sections conflict but that must be
3495          done later in decl_attributes since we are called before attributes
3496          are assigned.  */
3497       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3498         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3499
3500       /* Keep the old rtl since we can safely use it.  */
3501       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3502
3503       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3504         {
3505           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3506             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3507           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3508             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3509           DECL_NO_LIMIT_STACK (newdecl)
3510             |= DECL_NO_LIMIT_STACK (olddecl);
3511         }
3512     }
3513   /* If cannot merge, then use the new type and qualifiers,
3514      and don't preserve the old rtl.  */
3515   else
3516     {
3517       /* Clean out any memory we had of the old declaration.  */
3518       tree oldstatic = value_member (olddecl, static_aggregates);
3519       if (oldstatic)
3520         TREE_VALUE (oldstatic) = error_mark_node;
3521
3522       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3523       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3524       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3525       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3526     }
3527
3528   /* Merge the storage class information.  */
3529   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3530   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3531   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3532   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3533   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3534   if (! DECL_EXTERNAL (olddecl))
3535     DECL_EXTERNAL (newdecl) = 0;
3536
3537   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3538     {
3539       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3540       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3541       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3542       DECL_TEMPLATE_INSTANTIATED (newdecl)
3543         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3544       /* Don't really know how much of the language-specific
3545          values we should copy from old to new.  */
3546       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3547       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3548       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3549       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3550       olddecl_friend = DECL_FRIEND_P (olddecl);
3551
3552       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3553       if (TREE_CODE (newdecl) == FUNCTION_DECL
3554           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3555         DECL_BEFRIENDING_CLASSES (newdecl)
3556           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3557                      DECL_BEFRIENDING_CLASSES (olddecl));
3558     }
3559
3560   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3561     {
3562       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3563           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3564         {
3565           /* If newdecl is not a specialization, then it is not a
3566              template-related function at all.  And that means that we
3567              shoud have exited above, returning 0.  */
3568           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3569                               0);
3570
3571           if (TREE_USED (olddecl))
3572             /* From [temp.expl.spec]:
3573
3574                If a template, a member template or the member of a class
3575                template is explicitly specialized then that
3576                specialization shall be declared before the first use of
3577                that specialization that would cause an implicit
3578                instantiation to take place, in every translation unit in
3579                which such a use occurs.  */
3580             cp_error ("explicit specialization of %D after first use",
3581                       olddecl);
3582
3583           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3584         }
3585       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3586
3587       /* If either decl says `inline', this fn is inline, unless its
3588          definition was passed already.  */
3589       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3590         DECL_INLINE (olddecl) = 1;
3591       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3592
3593       if (! types_match)
3594         {
3595           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3596           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3597           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3598         }
3599       if (! types_match || new_defines_function)
3600         {
3601           /* These need to be copied so that the names are available.
3602              Note that if the types do match, we'll preserve inline
3603              info and other bits, but if not, we won't.  */
3604           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3605           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3606         }
3607       if (new_defines_function)
3608         /* If defining a function declared with other language
3609            linkage, use the previously declared language linkage.  */
3610         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3611       else if (types_match)
3612         {
3613           /* If redeclaring a builtin function, and not a definition,
3614              it stays built in.  */
3615           if (DECL_BUILT_IN (olddecl))
3616             {
3617               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3618               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3619               /* If we're keeping the built-in definition, keep the rtl,
3620                  regardless of declaration matches.  */
3621               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3622             }
3623           else
3624             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3625
3626           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3627           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3628             /* Previously saved insns go together with
3629                the function's previous definition.  */
3630             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3631           /* Don't clear out the arguments if we're redefining a function.  */
3632           if (DECL_ARGUMENTS (olddecl))
3633             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3634         }
3635     }
3636
3637   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3638     {
3639       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3640     }
3641
3642   /* Now preserve various other info from the definition.  */
3643   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3644   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3645   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3646   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3647
3648   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3649     {
3650       int function_size;
3651
3652       function_size = sizeof (struct tree_decl);
3653
3654       bcopy ((char *) newdecl + sizeof (struct tree_common),
3655              (char *) olddecl + sizeof (struct tree_common),
3656              function_size - sizeof (struct tree_common));
3657
3658       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3659         {
3660           /* If newdecl is a template instantiation, it is possible that
3661              the following sequence of events has occurred:
3662
3663              o A friend function was declared in a class template.  The
3664              class template was instantiated.
3665
3666              o The instantiation of the friend declaration was
3667              recorded on the instantiation list, and is newdecl.
3668
3669              o Later, however, instantiate_class_template called pushdecl
3670              on the newdecl to perform name injection.  But, pushdecl in
3671              turn called duplicate_decls when it discovered that another
3672              declaration of a global function with the same name already
3673              existed.
3674
3675              o Here, in duplicate_decls, we decided to clobber newdecl.
3676
3677              If we're going to do that, we'd better make sure that
3678              olddecl, and not newdecl, is on the list of
3679              instantiations so that if we try to do the instantiation
3680              again we won't get the clobbered declaration.  */
3681
3682           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3683           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3684
3685           for (; decls; decls = TREE_CHAIN (decls))
3686             if (TREE_VALUE (decls) == newdecl)
3687               TREE_VALUE (decls) = olddecl;
3688         }
3689     }
3690   else
3691     {
3692       bcopy ((char *) newdecl + sizeof (struct tree_common),
3693              (char *) olddecl + sizeof (struct tree_common),
3694              sizeof (struct tree_decl) - sizeof (struct tree_common)
3695              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3696     }
3697
3698   DECL_UID (olddecl) = olddecl_uid;
3699   if (olddecl_friend)
3700     DECL_FRIEND_P (olddecl) = 1;
3701
3702   /* NEWDECL contains the merged attribute lists.
3703      Update OLDDECL to be the same.  */
3704   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3705
3706   return 1;
3707 }
3708
3709 /* Record a decl-node X as belonging to the current lexical scope.
3710    Check for errors (such as an incompatible declaration for the same
3711    name already seen in the same scope).
3712
3713    Returns either X or an old decl for the same name.
3714    If an old decl is returned, it may have been smashed
3715    to agree with what X says.  */
3716
3717 tree
3718 pushdecl (x)
3719      tree x;
3720 {
3721   register tree t;
3722   register tree name;
3723   int need_new_binding;
3724
3725   /* We shouldn't be calling pushdecl when we're generating RTL for a
3726      function that we already did semantic analysis on previously.  */
3727   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3728                       19990913);
3729
3730   name = DECL_ASSEMBLER_NAME (x);
3731   need_new_binding = 1;
3732
3733   if (DECL_TEMPLATE_PARM_P (x))
3734     /* Template parameters have no context; they are not X::T even
3735        when declared within a class or namespace.  */
3736     ;
3737   else
3738     {
3739       if (current_function_decl && x != current_function_decl
3740           /* A local declaration for a function doesn't constitute
3741              nesting.  */
3742           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3743           /* A local declaration for an `extern' variable is in the
3744              scoped of the current namespace, not the current
3745              function.  */
3746           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3747           && !DECL_CONTEXT (x))
3748         DECL_CONTEXT (x) = current_function_decl;
3749       if (!DECL_CONTEXT (x))
3750         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3751
3752       /* If this is the declaration for a namespace-scope function,
3753          but the declaration itself is in a local scope, mark the
3754          declaration.  */
3755       if (TREE_CODE (x) == FUNCTION_DECL
3756           && DECL_NAMESPACE_SCOPE_P (x)
3757           && current_function_decl
3758           && x != current_function_decl)
3759         DECL_LOCAL_FUNCTION_P (x) = 1;
3760     }
3761
3762   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3763      compiler wants to use.  */
3764   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3765       || TREE_CODE (x) == NAMESPACE_DECL)
3766     name = DECL_NAME (x);
3767
3768   if (name)
3769     {
3770 #if 0
3771       /* Not needed...see below.  */
3772       char *file;
3773       int line;
3774 #endif
3775       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3776         name = TREE_OPERAND (name, 0);
3777
3778       /* Namespace-scoped variables are not found in the current level. */
3779       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3780         t = namespace_binding (name, DECL_CONTEXT (x));
3781       else
3782         t = lookup_name_current_level (name);
3783       if (t == error_mark_node)
3784         {
3785           /* error_mark_node is 0 for a while during initialization!  */
3786           t = NULL_TREE;
3787           cp_error_at ("`%#D' used prior to declaration", x);
3788         }
3789
3790       else if (t != NULL_TREE)
3791         {
3792 #if 0
3793           /* This is turned off until I have time to do it right (bpk).  */
3794           /* With the code below that uses it...  */
3795           file = DECL_SOURCE_FILE (t);
3796           line = DECL_SOURCE_LINE (t);
3797 #endif
3798           if (TREE_CODE (t) == PARM_DECL)
3799             {
3800               if (DECL_CONTEXT (t) == NULL_TREE)
3801                 fatal ("parse errors have confused me too much");
3802
3803               /* Check for duplicate params.  */
3804               if (duplicate_decls (x, t))
3805                 return t;
3806             }
3807           else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3808                     || DECL_FUNCTION_TEMPLATE_P (x))
3809                    && is_overloaded_fn (t))
3810             /* Don't do anything just yet. */;
3811           else if (t == wchar_decl_node)
3812             {
3813               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3814                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3815
3816               /* Throw away the redeclaration.  */
3817               return t;
3818             }
3819           else if (TREE_CODE (t) != TREE_CODE (x))
3820             {
3821               if (duplicate_decls (x, t))
3822                 return t;
3823             }
3824           else if (duplicate_decls (x, t))
3825             {
3826 #if 0
3827               /* This is turned off until I have time to do it right (bpk).  */
3828
3829               /* Also warn if they did a prototype with `static' on it, but
3830                  then later left the `static' off.  */
3831               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3832                 {
3833                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3834                     return t;
3835
3836                   if (extra_warnings)
3837                     {
3838                       cp_warning ("`static' missing from declaration of `%D'",
3839                                   t);
3840                       warning_with_file_and_line (file, line,
3841                                                   "previous declaration of `%s'",
3842                                                   decl_as_string (t, 0));
3843                     }
3844
3845                   /* Now fix things so it'll do what they expect.  */
3846                   if (current_function_decl)
3847                     TREE_PUBLIC (current_function_decl) = 0;
3848                 }
3849               /* Due to interference in memory reclamation (X may be
3850                  obstack-deallocated at this point), we must guard against
3851                  one really special case.  [jason: This should be handled
3852                  by start_function]  */
3853               if (current_function_decl == x)
3854                 current_function_decl = t;
3855 #endif
3856               if (TREE_CODE (t) == TYPE_DECL)
3857                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3858               else if (TREE_CODE (t) == FUNCTION_DECL)
3859                 check_default_args (t);
3860
3861               return t;
3862             }
3863           else if (DECL_MAIN_P (x))
3864             {
3865               /* A redeclaration of main, but not a duplicate of the
3866                  previous one.
3867
3868                  [basic.start.main]
3869
3870                  This function shall not be overloaded.  */
3871               cp_error_at ("invalid redeclaration of `%D'", t);
3872               cp_error ("as `%D'", x);
3873               /* We don't try to push this declaration since that
3874                  causes a crash.  */
3875               return x;
3876             }
3877         }
3878
3879       check_template_shadow (x);
3880
3881       /* If this is a function conjured up by the backend, massage it
3882          so it looks friendly.  */
3883       if (TREE_CODE (x) == FUNCTION_DECL
3884           && ! DECL_LANG_SPECIFIC (x))
3885         {
3886           retrofit_lang_decl (x);
3887           DECL_LANGUAGE (x) = lang_c;
3888         }
3889
3890       if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3891         {
3892           t = push_overloaded_decl (x, PUSH_LOCAL);
3893           if (t != x)
3894             return t;
3895           if (!namespace_bindings_p ())
3896             /* We do not need to create a binding for this name;
3897                push_overloaded_decl will have already done so if
3898                necessary.  */
3899             need_new_binding = 0;
3900         }
3901       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3902         {
3903           t = push_overloaded_decl (x, PUSH_GLOBAL);
3904           if (t == x)
3905             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3906           return t;
3907         }
3908
3909       /* If declaring a type as a typedef, copy the type (unless we're
3910          at line 0), and install this TYPE_DECL as the new type's typedef
3911          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3912       if (TREE_CODE (x) == TYPE_DECL)
3913         {
3914           tree type = TREE_TYPE (x);
3915           if (DECL_SOURCE_LINE (x) == 0)
3916             {
3917               if (TYPE_NAME (type) == 0)
3918                 TYPE_NAME (type) = x;
3919             }
3920           else if (type != error_mark_node && TYPE_NAME (type) != x
3921                    /* We don't want to copy the type when all we're
3922                       doing is making a TYPE_DECL for the purposes of
3923                       inlining.  */
3924                    && (!TYPE_NAME (type)
3925                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3926             {
3927               DECL_ORIGINAL_TYPE (x) = type;
3928               type = build_type_copy (type);
3929               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3930               TYPE_NAME (type) = x;
3931               TREE_TYPE (x) = type;
3932             }
3933
3934           if (type != error_mark_node
3935               && TYPE_NAME (type)
3936               && TYPE_IDENTIFIER (type))
3937             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3938                                                   current_binding_level);
3939
3940         }
3941
3942       /* Multiple external decls of the same identifier ought to match.
3943
3944          We get warnings about inline functions where they are defined.
3945          We get warnings about other functions from push_overloaded_decl.
3946
3947          Avoid duplicate warnings where they are used.  */
3948       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3949         {
3950           tree decl;
3951
3952           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3953               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3954                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3955             decl = IDENTIFIER_NAMESPACE_VALUE (name);
3956           else
3957             decl = NULL_TREE;
3958
3959           if (decl
3960               /* If different sort of thing, we already gave an error.  */
3961               && TREE_CODE (decl) == TREE_CODE (x)
3962               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3963             {
3964               cp_pedwarn ("type mismatch with previous external decl", x);
3965               cp_pedwarn_at ("previous external decl of `%#D'", decl);
3966             }
3967         }
3968
3969       /* This name is new in its binding level.
3970          Install the new declaration and return it.  */
3971       if (namespace_bindings_p ())
3972         {
3973           /* Install a global value.  */
3974
3975           /* If the first global decl has external linkage,
3976              warn if we later see static one.  */
3977           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3978             TREE_PUBLIC (name) = 1;
3979
3980           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3981                 && t != NULL_TREE)
3982               /* For an ordinary function, we create a binding from
3983                  the mangled name (i.e., NAME) to the DECL.  But, for
3984                  an `extern "C"' function, the mangled name and the
3985                  ordinary name are the same so we need not do this.  */
3986               && !(TREE_CODE (x) == FUNCTION_DECL &&
3987                    DECL_LANGUAGE (x) == lang_c))
3988             {
3989               if (TREE_CODE (x) == FUNCTION_DECL)
3990                 my_friendly_assert
3991                   ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
3992                   || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
3993               SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3994             }
3995
3996           /* Don't forget if the function was used via an implicit decl.  */
3997           if (IDENTIFIER_IMPLICIT_DECL (name)
3998               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3999             TREE_USED (x) = 1;
4000
4001           /* Don't forget if its address was taken in that way.  */
4002           if (IDENTIFIER_IMPLICIT_DECL (name)
4003               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4004             TREE_ADDRESSABLE (x) = 1;
4005
4006           /* Warn about mismatches against previous implicit decl.  */
4007           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4008               /* If this real decl matches the implicit, don't complain.  */
4009               && ! (TREE_CODE (x) == FUNCTION_DECL
4010                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4011             cp_warning
4012               ("`%D' was previously implicitly declared to return `int'", x);
4013
4014           /* If new decl is `static' and an `extern' was seen previously,
4015              warn about it.  */
4016           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4017             warn_extern_redeclared_static (x, t);
4018         }
4019       else
4020         {
4021           /* Here to install a non-global value.  */
4022           tree oldlocal = IDENTIFIER_VALUE (name);
4023           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4024
4025           if (need_new_binding)
4026             {
4027               push_local_binding (name, x, 0);
4028               /* Because push_local_binding will hook X on to the
4029                  current_binding_level's name list, we don't want to
4030                  do that again below.  */
4031               need_new_binding = 0;
4032             }
4033
4034           /* If this is a TYPE_DECL, push it into the type value slot.  */
4035           if (TREE_CODE (x) == TYPE_DECL)
4036             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4037                                                   current_binding_level);
4038
4039           /* Clear out any TYPE_DECL shadowed by a namespace so that
4040              we won't think this is a type.  The C struct hack doesn't
4041              go through namespaces.  */
4042           if (TREE_CODE (x) == NAMESPACE_DECL)
4043             set_identifier_type_value_with_scope (name, NULL_TREE,
4044                                                   current_binding_level);
4045
4046           if (oldlocal)
4047             {
4048               tree d = oldlocal;
4049
4050               while (oldlocal
4051                      && TREE_CODE (oldlocal) == VAR_DECL
4052                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4053                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4054
4055               if (oldlocal == NULL_TREE)
4056                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4057             }
4058
4059           /* If this is an extern function declaration, see if we
4060              have a global definition or declaration for the function.  */
4061           if (oldlocal == NULL_TREE
4062               && DECL_EXTERNAL (x)
4063               && oldglobal != NULL_TREE
4064               && TREE_CODE (x) == FUNCTION_DECL
4065               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4066             {
4067               /* We have one.  Their types must agree.  */
4068               if (decls_match (x, oldglobal))
4069                 /* OK */;
4070               else
4071                 {
4072                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4073                   cp_warning_at ("global declaration `%#D'", oldglobal);
4074                 }
4075             }
4076           /* If we have a local external declaration,
4077              and no file-scope declaration has yet been seen,
4078              then if we later have a file-scope decl it must not be static.  */
4079           if (oldlocal == NULL_TREE
4080               && oldglobal == NULL_TREE
4081               && DECL_EXTERNAL (x)
4082               && TREE_PUBLIC (x))
4083             TREE_PUBLIC (name) = 1;
4084
4085           /* Warn if shadowing an argument at the top level of the body.  */
4086           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4087               /* Inline decls shadow nothing.  */
4088               && !DECL_FROM_INLINE (x)
4089               && TREE_CODE (oldlocal) == PARM_DECL
4090               /* Don't complain if it's from an enclosing function.  */
4091               && DECL_CONTEXT (oldlocal) == current_function_decl
4092               && TREE_CODE (x) != PARM_DECL)
4093             {
4094               /* Go to where the parms should be and see if we
4095                  find them there.  */
4096               struct binding_level *b = current_binding_level->level_chain;
4097
4098               if (cleanup_label)
4099                 b = b->level_chain;
4100
4101               /* ARM $8.3 */
4102               if (b->parm_flag == 1)
4103                 cp_error ("declaration of `%#D' shadows a parameter", name);
4104             }
4105
4106           /* Maybe warn if shadowing something else.  */
4107           if (warn_shadow && !DECL_EXTERNAL (x)
4108               /* Inline decls shadow nothing.  */
4109               && !DECL_FROM_INLINE (x)
4110               /* No shadow warnings for internally generated vars.  */
4111               && ! DECL_ARTIFICIAL (x)
4112               /* No shadow warnings for vars made for inlining.  */
4113               && ! DECL_FROM_INLINE (x))
4114             {
4115               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4116                 warning ("declaration of `%s' shadows a parameter",
4117                         IDENTIFIER_POINTER (name));
4118               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4119                        && current_class_ptr
4120                        && !TREE_STATIC (name))
4121                 warning ("declaration of `%s' shadows a member of `this'",
4122                         IDENTIFIER_POINTER (name));
4123               else if (oldlocal != NULL_TREE)
4124                 warning ("declaration of `%s' shadows previous local",
4125                         IDENTIFIER_POINTER (name));
4126               else if (oldglobal != NULL_TREE)
4127                 /* XXX shadow warnings in outer-more namespaces */
4128                 warning ("declaration of `%s' shadows global declaration",
4129                         IDENTIFIER_POINTER (name));
4130             }
4131         }
4132
4133       if (TREE_CODE (x) == FUNCTION_DECL)
4134         check_default_args (x);
4135
4136       /* Keep count of variables in this level with incomplete type.  */
4137       if (TREE_CODE (x) == VAR_DECL
4138           && TREE_TYPE (x) != error_mark_node
4139           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4140                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4141               /* RTTI TD entries are created while defining the type_info.  */
4142               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4143                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4144         {
4145           if (namespace_bindings_p ())
4146             namespace_scope_incomplete
4147               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4148           else
4149             current_binding_level->incomplete
4150               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4151         }
4152     }
4153
4154   if (need_new_binding)
4155     add_decl_to_level (x,
4156                        DECL_NAMESPACE_SCOPE_P (x)
4157                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4158                        : current_binding_level);
4159
4160   return x;
4161 }
4162
4163 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4164    caller to set DECL_CONTEXT properly.  */
4165
4166 static tree
4167 pushdecl_with_scope (x, level)
4168      tree x;
4169      struct binding_level *level;
4170 {
4171   register struct binding_level *b;
4172   tree function_decl = current_function_decl;
4173
4174   current_function_decl = NULL_TREE;
4175   if (level->parm_flag == 2)
4176     {
4177       b = class_binding_level;
4178       class_binding_level = level;
4179       pushdecl_class_level (x);
4180       class_binding_level = b;
4181     }
4182   else
4183     {
4184       b = current_binding_level;
4185       current_binding_level = level;
4186       x = pushdecl (x);
4187       current_binding_level = b;
4188     }
4189   current_function_decl = function_decl;
4190   return x;
4191 }
4192
4193 /* Like pushdecl, only it places X in the current namespace,
4194    if appropriate.  */
4195
4196 tree
4197 pushdecl_namespace_level (x)
4198      tree x;
4199 {
4200   register struct binding_level *b = current_binding_level;
4201   register tree t;
4202
4203   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4204
4205   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4206      what we want.  */
4207   if (TREE_CODE (x) == TYPE_DECL)
4208     {
4209       tree name = DECL_NAME (x);
4210       tree newval;
4211       tree *ptr = (tree *)0;
4212       for (; b != global_binding_level; b = b->level_chain)
4213         {
4214           tree shadowed = b->type_shadowed;
4215           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4216             if (TREE_PURPOSE (shadowed) == name)
4217               {
4218                 ptr = &TREE_VALUE (shadowed);
4219                 /* Can't break out of the loop here because sometimes
4220                    a binding level will have duplicate bindings for
4221                    PT names.  It's gross, but I haven't time to fix it.  */
4222               }
4223         }
4224       newval = TREE_TYPE (x);
4225       if (ptr == (tree *)0)
4226         {
4227           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4228              up here if this is changed to an assertion.  --KR  */
4229           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4230         }
4231       else
4232         {
4233           *ptr = newval;
4234         }
4235     }
4236   return t;
4237 }
4238
4239 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4240    if appropriate.  */
4241
4242 tree
4243 pushdecl_top_level (x)
4244      tree x;
4245 {
4246   push_to_top_level ();
4247   x = pushdecl_namespace_level (x);
4248   pop_from_top_level ();
4249   return x;
4250 }
4251
4252 /* Make the declaration of X appear in CLASS scope.  */
4253
4254 void
4255 pushdecl_class_level (x)
4256      tree x;
4257 {
4258   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4259      scope looks for the pre-mangled name.  */
4260   register tree name;
4261
4262   if (TREE_CODE (x) == OVERLOAD)
4263     x = OVL_CURRENT (x);
4264   name = DECL_NAME (x);
4265
4266   if (name)
4267     {
4268       push_class_level_binding (name, x);
4269       if (TREE_CODE (x) == TYPE_DECL)
4270         set_identifier_type_value (name, TREE_TYPE (x));
4271     }
4272   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4273     {
4274       tree f;
4275
4276       for (f = TYPE_FIELDS (TREE_TYPE (x));
4277            f;
4278            f = TREE_CHAIN (f))
4279         pushdecl_class_level (f);
4280     }
4281 }
4282
4283 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4284    DECL, or a modified version thereof.  */
4285
4286 tree
4287 maybe_push_decl (decl)
4288      tree decl;
4289 {
4290   tree type = TREE_TYPE (decl);
4291
4292   /* Add this decl to the current binding level, but not if it comes
4293      from another scope, e.g. a static member variable.  TEM may equal
4294      DECL or it may be a previous decl of the same name.  */
4295   if (decl == error_mark_node
4296       || (TREE_CODE (decl) != PARM_DECL
4297           && DECL_CONTEXT (decl) != NULL_TREE
4298           /* Definitions of namespace members outside their namespace are
4299              possible. */
4300           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4301       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4302       || TREE_CODE (type) == UNKNOWN_TYPE
4303       /* The declaration of a template specialization does not affect
4304          the functions available for overload resolution, so we do not
4305          call pushdecl.  */
4306       || (TREE_CODE (decl) == FUNCTION_DECL
4307           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4308     return decl;
4309   else
4310     return pushdecl (decl);
4311 }
4312
4313 /* Make the declaration(s) of X appear in CLASS scope
4314    under the name NAME.  */
4315
4316 void
4317 push_class_level_binding (name, x)
4318      tree name;
4319      tree x;
4320 {
4321   tree binding;
4322   /* The class_binding_level will be NULL if x is a template
4323      parameter name in a member template.  */
4324   if (!class_binding_level)
4325     return;
4326
4327   /* Make sure that this new member does not have the same name
4328      as a template parameter.  */
4329   if (TYPE_BEING_DEFINED (current_class_type))
4330     check_template_shadow (x);
4331
4332   /* If this declaration shadows a declaration from an enclosing
4333      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4334      we leave this class.  Record the shadowed declaration here.  */
4335   binding = IDENTIFIER_BINDING (name);
4336   if (binding
4337       && ((TREE_CODE (x) == OVERLOAD
4338            && BINDING_VALUE (binding)
4339            && is_overloaded_fn (BINDING_VALUE (binding)))
4340           || INHERITED_VALUE_BINDING_P (binding)))
4341     {
4342       tree shadow;
4343       tree old_decl;
4344
4345       /* If the old binding was from a base class, and was for a tag
4346          name, slide it over to make room for the new binding.  The
4347          old binding is still visible if explicitly qualified with a
4348          class-key.  */
4349       if (INHERITED_VALUE_BINDING_P (binding)
4350           && BINDING_VALUE (binding)
4351           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4352           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4353           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4354         {
4355           old_decl = BINDING_TYPE (binding);
4356           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4357           BINDING_VALUE (binding) = NULL_TREE;
4358           INHERITED_VALUE_BINDING_P (binding) = 0;
4359         }
4360       else
4361         old_decl = BINDING_VALUE (binding);
4362
4363       /* There was already a binding for X containing fewer
4364          functions than are named in X.  Find the previous
4365          declaration of X on the class-shadowed list, and update it.  */
4366       for (shadow = class_binding_level->class_shadowed;
4367            shadow;
4368            shadow = TREE_CHAIN (shadow))
4369         if (TREE_PURPOSE (shadow) == name
4370             && TREE_TYPE (shadow) == old_decl)
4371           {
4372             BINDING_VALUE (binding) = x;
4373             INHERITED_VALUE_BINDING_P (binding) = 0;
4374             TREE_TYPE (shadow) = x;
4375             return;
4376           }
4377     }
4378
4379   /* If we didn't replace an existing binding, put the binding on the
4380      stack of bindings for the identifier, and update
4381      IDENTIFIER_CLASS_VALUE.  */
4382   if (push_class_binding (name, x))
4383     {
4384       class_binding_level->class_shadowed
4385         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4386                      class_binding_level->class_shadowed);
4387       /* Record the value we are binding NAME to so that we can know
4388          what to pop later.  */
4389       TREE_TYPE (class_binding_level->class_shadowed) = x;
4390     }
4391 }
4392
4393 /* Insert another USING_DECL into the current binding level,
4394    returning this declaration. If this is a redeclaration,
4395    do nothing and return NULL_TREE.  */
4396
4397 tree
4398 push_using_decl (scope, name)
4399      tree scope;
4400      tree name;
4401 {
4402   tree decl;
4403
4404   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4405   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4406   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4407     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4408       break;
4409   if (decl)
4410     return NULL_TREE;
4411   decl = build_lang_decl (USING_DECL, name, void_type_node);
4412   DECL_INITIAL (decl) = scope;
4413   TREE_CHAIN (decl) = current_binding_level->usings;
4414   current_binding_level->usings = decl;
4415   return decl;
4416 }
4417
4418 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4419    changed (i.e. there was already a directive), or the fresh
4420    TREE_LIST otherwise.  */
4421
4422 tree
4423 push_using_directive (used)
4424      tree used;
4425 {
4426   tree ud = current_binding_level->using_directives;
4427   tree iter, ancestor;
4428
4429   /* Check if we already have this. */
4430   if (purpose_member (used, ud) != NULL_TREE)
4431     return NULL_TREE;
4432
4433   /* Recursively add all namespaces used. */
4434   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4435     push_using_directive (TREE_PURPOSE (iter));
4436
4437   ancestor = namespace_ancestor (current_decl_namespace (), used);
4438   ud = current_binding_level->using_directives;
4439   ud = tree_cons (used, ancestor, ud);
4440   current_binding_level->using_directives = ud;
4441   return ud;
4442 }
4443
4444 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4445    other definitions already in place.  We get around this by making
4446    the value of the identifier point to a list of all the things that
4447    want to be referenced by that name.  It is then up to the users of
4448    that name to decide what to do with that list.
4449
4450    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4451    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4452
4453    FLAGS is a bitwise-or of the following values:
4454      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4455                  namespace scope.
4456      PUSH_USING: DECL is being pushed as the result of a using
4457                  declaration.
4458
4459    The value returned may be a previous declaration if we guessed wrong
4460    about what language DECL should belong to (C or C++).  Otherwise,
4461    it's always DECL (and never something that's not a _DECL).  */
4462
4463 tree
4464 push_overloaded_decl (decl, flags)
4465      tree decl;
4466      int flags;
4467 {
4468   tree name = DECL_NAME (decl);
4469   tree old;
4470   tree new_binding;
4471   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4472
4473   if (doing_global)
4474     old = namespace_binding (name, DECL_CONTEXT (decl));
4475   else
4476     old = lookup_name_current_level (name);
4477
4478   if (old)
4479     {
4480       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4481         {
4482           tree t = TREE_TYPE (old);
4483           if (IS_AGGR_TYPE (t) && warn_shadow
4484               && (! DECL_IN_SYSTEM_HEADER (decl)
4485                   || ! DECL_IN_SYSTEM_HEADER (old)))
4486             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4487           old = NULL_TREE;
4488         }
4489       else if (is_overloaded_fn (old))
4490         {
4491           tree tmp;
4492
4493           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4494             {
4495               tree fn = OVL_CURRENT (tmp);
4496
4497               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4498                   && !(flags & PUSH_USING)
4499                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4500                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4501                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4502                           decl, fn);
4503
4504               if (duplicate_decls (decl, fn))
4505                 return fn;
4506             }
4507         }
4508       else
4509         {
4510           cp_error_at ("previous non-function declaration `%#D'", old);
4511           cp_error ("conflicts with function declaration `%#D'", decl);
4512           return decl;
4513         }
4514     }
4515
4516   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4517     {
4518       if (old && TREE_CODE (old) != OVERLOAD)
4519         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4520       else
4521         new_binding = ovl_cons (decl, old);
4522       if (flags & PUSH_USING)
4523         OVL_USED (new_binding) = 1;
4524     }
4525   else
4526     /* NAME is not ambiguous.  */
4527     new_binding = decl;
4528
4529   if (doing_global)
4530     set_namespace_binding (name, current_namespace, new_binding);
4531   else
4532     {
4533       /* We only create an OVERLOAD if there was a previous binding at
4534          this level, or if decl is a template. In the former case, we
4535          need to remove the old binding and replace it with the new
4536          binding.  We must also run through the NAMES on the binding
4537          level where the name was bound to update the chain.  */
4538
4539       if (TREE_CODE (new_binding) == OVERLOAD && old)
4540         {
4541           tree *d;
4542
4543           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4544                *d;
4545                d = &TREE_CHAIN (*d))
4546             if (*d == old
4547                 || (TREE_CODE (*d) == TREE_LIST
4548                     && TREE_VALUE (*d) == old))
4549               {
4550                 if (TREE_CODE (*d) == TREE_LIST)
4551                   /* Just replace the old binding with the new.  */
4552                   TREE_VALUE (*d) = new_binding;
4553                 else
4554                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4555                   *d = tree_cons (NULL_TREE, new_binding,
4556                                   TREE_CHAIN (*d));
4557
4558                 /* And update the CPLUS_BINDING node.  */
4559                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4560                   = new_binding;
4561                 return decl;
4562               }
4563
4564           /* We should always find a previous binding in this case.  */
4565           my_friendly_abort (0);
4566         }
4567
4568       /* Install the new binding.  */
4569       push_local_binding (name, new_binding, flags);
4570     }
4571
4572   return decl;
4573 }
4574 \f
4575 /* Generate an implicit declaration for identifier FUNCTIONID
4576    as a function of type int ().  Print a warning if appropriate.  */
4577
4578 tree
4579 implicitly_declare (functionid)
4580      tree functionid;
4581 {
4582   register tree decl;
4583
4584   /* We used to reuse an old implicit decl here,
4585      but this loses with inline functions because it can clobber
4586      the saved decl chains.  */
4587   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4588
4589   DECL_EXTERNAL (decl) = 1;
4590   TREE_PUBLIC (decl) = 1;
4591
4592   /* ISO standard says implicit declarations are in the innermost block.
4593      So we record the decl in the standard fashion.  */
4594   pushdecl (decl);
4595   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4596
4597   if (warn_implicit
4598       /* Only one warning per identifier.  */
4599       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4600     {
4601       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4602     }
4603
4604   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4605
4606   return decl;
4607 }
4608
4609 /* Return zero if the declaration NEWDECL is valid
4610    when the declaration OLDDECL (assumed to be for the same name)
4611    has already been seen.
4612    Otherwise return an error message format string with a %s
4613    where the identifier should go.  */
4614
4615 static const char *
4616 redeclaration_error_message (newdecl, olddecl)
4617      tree newdecl, olddecl;
4618 {
4619   if (TREE_CODE (newdecl) == TYPE_DECL)
4620     {
4621       /* Because C++ can put things into name space for free,
4622          constructs like "typedef struct foo { ... } foo"
4623          would look like an erroneous redeclaration.  */
4624       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4625         return 0;
4626       else
4627         return "redefinition of `%#D'";
4628     }
4629   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4630     {
4631       /* If this is a pure function, its olddecl will actually be
4632          the original initialization to `0' (which we force to call
4633          abort()).  Don't complain about redefinition in this case.  */
4634       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4635         return 0;
4636
4637       /* If both functions come from different namespaces, this is not
4638          a redeclaration - this is a conflict with a used function. */
4639       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4640           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4641         return "`%D' conflicts with used function";
4642
4643       /* We'll complain about linkage mismatches in
4644          warn_extern_redeclared_static.  */
4645
4646       /* Defining the same name twice is no good.  */
4647       if (DECL_INITIAL (olddecl) != NULL_TREE
4648           && DECL_INITIAL (newdecl) != NULL_TREE)
4649         {
4650           if (DECL_NAME (olddecl) == NULL_TREE)
4651             return "`%#D' not declared in class";
4652           else
4653             return "redefinition of `%#D'";
4654         }
4655       return 0;
4656     }
4657   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4658     {
4659       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4660            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4661            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4662           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4663               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4664               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4665         return "redefinition of `%#D'";
4666       return 0;
4667     }
4668   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4669     {
4670       /* Objects declared at top level:  */
4671       /* If at least one is a reference, it's ok.  */
4672       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4673         return 0;
4674       /* Reject two definitions.  */
4675       return "redefinition of `%#D'";
4676     }
4677   else
4678     {
4679       /* Objects declared with block scope:  */
4680       /* Reject two definitions, and reject a definition
4681          together with an external reference.  */
4682       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4683         return "redeclaration of `%#D'";
4684       return 0;
4685     }
4686 }
4687 \f
4688 /* Create a new label, named ID.  */
4689
4690 static tree
4691 make_label_decl (id, local_p)
4692      tree id;
4693      int local_p;
4694 {
4695   tree decl;
4696
4697   decl = build_decl (LABEL_DECL, id, void_type_node);
4698   if (expanding_p)
4699     /* Make sure every label has an rtx.  */
4700     label_rtx (decl);
4701
4702   DECL_CONTEXT (decl) = current_function_decl;
4703   DECL_MODE (decl) = VOIDmode;
4704   C_DECLARED_LABEL_FLAG (decl) = local_p;
4705
4706   /* Say where one reference is to the label, for the sake of the
4707      error if it is not defined.  */
4708   DECL_SOURCE_LINE (decl) = lineno;
4709   DECL_SOURCE_FILE (decl) = input_filename;
4710
4711   /* Record the fact that this identifier is bound to this label.  */
4712   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4713
4714   /* Record this label on the list of used labels so that we can check
4715      at the end of the function to see whether or not the label was
4716      actually defined.  */
4717   if ((named_label_uses == NULL || named_label_uses->label_decl != decl)
4718       && (named_label_uses == NULL
4719           || named_label_uses->names_in_scope != current_binding_level->names
4720           || named_label_uses->label_decl != decl))
4721     {
4722       struct named_label_list *new_ent;
4723       new_ent
4724         = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4725       new_ent->label_decl = decl;
4726       new_ent->names_in_scope = current_binding_level->names;
4727       new_ent->binding_level = current_binding_level;
4728       new_ent->lineno_o_goto = lineno;
4729       new_ent->filename_o_goto = input_filename;
4730       new_ent->next = named_label_uses;
4731       named_label_uses = new_ent;
4732     }
4733
4734   return decl;
4735 }
4736
4737 /* Look for a label named ID in the current function.  If one cannot
4738    be found, create one.  (We keep track of used, but undefined,
4739    labels, and complain about them at the end of a function.)  */
4740
4741 tree
4742 lookup_label (id)
4743      tree id;
4744 {
4745   tree decl;
4746
4747   /* You can't use labels at global scope.  */
4748   if (current_function_decl == NULL_TREE)
4749     {
4750       error ("label `%s' referenced outside of any function",
4751              IDENTIFIER_POINTER (id));
4752       return NULL_TREE;
4753     }
4754
4755   /* See if we've already got this label.  */
4756   decl = IDENTIFIER_LABEL_VALUE (id);
4757   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4758     return decl;
4759
4760   /* Record this label on the list of labels used in this function.
4761      We do this before calling make_label_decl so that we get the
4762      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4763   named_labels = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4764                             named_labels);
4765   /* We need a new label.  */
4766   decl = make_label_decl (id, /*local_p=*/0);
4767   /* Now fill in the information we didn't have before.  */
4768   TREE_VALUE (named_labels) = decl;
4769
4770   return decl;
4771 }
4772
4773 /* Declare a local label named ID.  */
4774
4775 tree
4776 declare_local_label (id)
4777      tree id;
4778 {
4779   tree decl;
4780
4781   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4782      this scope we can restore the old value of
4783      IDENTIFIER_TYPE_VALUE.  */
4784   current_binding_level->shadowed_labels
4785     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4786                  current_binding_level->shadowed_labels);
4787   /* Look for the label.  */
4788   decl = make_label_decl (id, /*local_p=*/1);
4789   /* Now fill in the information we didn't have before.  */
4790   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4791
4792   return decl;
4793 }
4794
4795 /* Define a label, specifying the location in the source file.
4796    Return the LABEL_DECL node for the label, if the definition is valid.
4797    Otherwise return 0.  */
4798
4799 tree
4800 define_label (filename, line, name)
4801      char *filename;
4802      int line;
4803      tree name;
4804 {
4805   tree decl = lookup_label (name);
4806
4807   /* After labels, make any new cleanups go into their
4808      own new (temporary) binding contour.  */
4809   current_binding_level->more_cleanups_ok = 0;
4810
4811   if (name == get_identifier ("wchar_t"))
4812     cp_pedwarn ("label named wchar_t");
4813
4814   if (DECL_INITIAL (decl) != NULL_TREE)
4815     {
4816       cp_error ("duplicate label `%D'", decl);
4817       return 0;
4818     }
4819   else
4820     {
4821       struct named_label_list *uses, *prev;
4822       int identified = 0;
4823       int saw_eh = 0;
4824
4825       /* Mark label as having been defined.  */
4826       DECL_INITIAL (decl) = error_mark_node;
4827       /* Say where in the source.  */
4828       DECL_SOURCE_FILE (decl) = filename;
4829       DECL_SOURCE_LINE (decl) = line;
4830
4831       prev = NULL;
4832       uses = named_label_uses;
4833       while (uses != NULL)
4834         if (uses->label_decl == decl)
4835           {
4836             struct binding_level *b = current_binding_level;
4837             while (b)
4838               {
4839                 tree new_decls = b->names;
4840                 tree old_decls = (b == uses->binding_level)
4841                                   ? uses->names_in_scope : NULL_TREE;
4842                 while (new_decls != old_decls)
4843                   {
4844                     if (TREE_CODE (new_decls) == VAR_DECL
4845                         /* Don't complain about crossing initialization
4846                            of internal entities.  They can't be accessed,
4847                            and they should be cleaned up
4848                            by the time we get to the label.  */
4849                         && ! DECL_ARTIFICIAL (new_decls)
4850                         && !(DECL_INITIAL (new_decls) == NULL_TREE
4851                              && pod_type_p (TREE_TYPE (new_decls))))
4852                       {
4853                         /* This is really only important if we're crossing
4854                            an initialization.  The POD stuff is just
4855                            pedantry; why should it matter if the class
4856                            contains a field of pointer to member type?  */
4857                         int problem = (DECL_INITIAL (new_decls)
4858                                        || (TYPE_NEEDS_CONSTRUCTING
4859                                            (TREE_TYPE (new_decls))));
4860
4861                         if (! identified)
4862                           {
4863                             if (problem)
4864                               {
4865                                 cp_error ("jump to label `%D'", decl);
4866                                 error_with_file_and_line
4867                                   (uses->filename_o_goto,
4868                                    uses->lineno_o_goto, "  from here");
4869                               }
4870                             else
4871                               {
4872                                 cp_pedwarn ("jump to label `%D'", decl);
4873                                 pedwarn_with_file_and_line
4874                                   (uses->filename_o_goto,
4875                                    uses->lineno_o_goto, "  from here");
4876                               }
4877                             identified = 1;
4878                           }
4879
4880                         if (problem)
4881                           cp_error_at ("  crosses initialization of `%#D'",
4882                                        new_decls);
4883                         else
4884                           cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4885                                          new_decls);
4886                       }
4887                     new_decls = TREE_CHAIN (new_decls);
4888                   }
4889                 if (b == uses->binding_level)
4890                   break;
4891                 if (b->eh_region && ! saw_eh)
4892                   {
4893                     if (! identified)
4894                       {
4895                         cp_error ("jump to label `%D'", decl);
4896                         error_with_file_and_line
4897                           (uses->filename_o_goto,
4898                            uses->lineno_o_goto, "  from here");
4899                         identified = 1;
4900                       }
4901                     error ("  enters exception handling block");
4902                     saw_eh = 1;
4903                   }
4904                 b = b->level_chain;
4905               }
4906
4907             if (prev != NULL)
4908               prev->next = uses->next;
4909             else
4910               named_label_uses = uses->next;
4911
4912             uses = uses->next;
4913           }
4914         else
4915           {
4916             prev = uses;
4917             uses = uses->next;
4918           }
4919       current_function_return_value = NULL_TREE;
4920       return decl;
4921     }
4922 }
4923
4924 struct cp_switch
4925 {
4926   struct binding_level *level;
4927   struct cp_switch *next;
4928 };
4929
4930 static struct cp_switch *switch_stack;
4931
4932 void
4933 push_switch ()
4934 {
4935   struct cp_switch *p
4936     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
4937   p->level = current_binding_level;
4938   p->next = switch_stack;
4939   switch_stack = p;
4940 }
4941
4942 void
4943 pop_switch ()
4944 {
4945   struct cp_switch *cs;
4946
4947   cs = switch_stack;
4948   switch_stack = switch_stack->next;
4949   free (cs);
4950 }
4951
4952 /* Note that we've seen a definition of a case label, and complain if this
4953    is a bad place for one.  */
4954
4955 void
4956 define_case_label ()
4957 {
4958   tree cleanup = last_cleanup_this_contour ();
4959   struct binding_level *b = current_binding_level;
4960   int identified = 0;
4961
4962   if (! switch_stack)
4963     /* Don't crash; we'll complain in do_case.  */
4964     return;
4965
4966   if (cleanup)
4967     {
4968       static int explained = 0;
4969       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4970       warning ("where case label appears here");
4971       if (!explained)
4972         {
4973           warning ("(enclose actions of previous case statements requiring");
4974           warning ("destructors in their own binding contours.)");
4975           explained = 1;
4976         }
4977     }
4978
4979   for (; b && b != switch_stack->level; b = b->level_chain)
4980     {
4981       tree new_decls = b->names;
4982       for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4983         {
4984           if (TREE_CODE (new_decls) == VAR_DECL
4985               /* Don't complain about crossing initialization
4986                  of internal entities.  They can't be accessed,
4987                  and they should be cleaned up
4988                  by the time we get to the label.  */
4989               && ! DECL_ARTIFICIAL (new_decls)
4990               && ((DECL_INITIAL (new_decls) != NULL_TREE
4991                    && DECL_INITIAL (new_decls) != error_mark_node)
4992                   || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4993             {
4994               if (! identified)
4995                 error ("jump to case label");
4996               identified = 1;
4997               cp_error_at ("  crosses initialization of `%#D'",
4998                            new_decls);
4999             }
5000         }
5001     }
5002
5003   /* After labels, make any new cleanups go into their
5004      own new (temporary) binding contour.  */
5005
5006   current_binding_level->more_cleanups_ok = 0;
5007   current_function_return_value = NULL_TREE;
5008 }
5009 \f
5010 /* Return the list of declarations of the current level.
5011    Note that this list is in reverse order unless/until
5012    you nreverse it; and when you do nreverse it, you must
5013    store the result back using `storedecls' or you will lose.  */
5014
5015 tree
5016 getdecls ()
5017 {
5018   return current_binding_level->names;
5019 }
5020
5021 /* Return the list of type-tags (for structs, etc) of the current level.  */
5022
5023 tree
5024 gettags ()
5025 {
5026   return current_binding_level->tags;
5027 }
5028
5029 /* Store the list of declarations of the current level.
5030    This is done for the parameter declarations of a function being defined,
5031    after they are modified in the light of any missing parameters.  */
5032
5033 static void
5034 storedecls (decls)
5035      tree decls;
5036 {
5037   current_binding_level->names = decls;
5038 }
5039
5040 /* Similarly, store the list of tags of the current level.  */
5041
5042 void
5043 storetags (tags)
5044      tree tags;
5045 {
5046   current_binding_level->tags = tags;
5047 }
5048 \f
5049 /* Given NAME, an IDENTIFIER_NODE,
5050    return the structure (or union or enum) definition for that name.
5051    Searches binding levels from BINDING_LEVEL up to the global level.
5052    If THISLEVEL_ONLY is nonzero, searches only the specified context
5053    (but skips any tag-transparent contexts to find one that is
5054    meaningful for tags).
5055    FORM says which kind of type the caller wants;
5056    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5057    If the wrong kind of type is found, and it's not a template, an error is
5058    reported.  */
5059
5060 static tree
5061 lookup_tag (form, name, binding_level, thislevel_only)
5062      enum tree_code form;
5063      tree name;
5064      struct binding_level *binding_level;
5065      int thislevel_only;
5066 {
5067   register struct binding_level *level;
5068   /* Non-zero if, we should look past a template parameter level, even
5069      if THISLEVEL_ONLY.  */
5070   int allow_template_parms_p = 1;
5071
5072   for (level = binding_level; level; level = level->level_chain)
5073     {
5074       register tree tail;
5075       if (ANON_AGGRNAME_P (name))
5076         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5077           {
5078             /* There's no need for error checking here, because
5079                anon names are unique throughout the compilation.  */
5080             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5081               return TREE_VALUE (tail);
5082           }
5083       else if (level->namespace_p)
5084         /* Do namespace lookup. */
5085         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5086           {
5087             tree old = binding_for_name (name, tail);
5088
5089             /* If we just skipped past a template parameter level,
5090                even though THISLEVEL_ONLY, and we find a template
5091                class declaration, then we use the _TYPE node for the
5092                template.  See the example below.  */
5093             if (thislevel_only && !allow_template_parms_p
5094                 && old && BINDING_VALUE (old)
5095                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5096               old = TREE_TYPE (BINDING_VALUE (old));
5097             else
5098               old = BINDING_TYPE (old);
5099
5100             /* If it has an original type, it is a typedef, and we
5101                should not return it.  */
5102             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5103               old = NULL_TREE;
5104             if (old && TREE_CODE (old) != form
5105                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5106               {
5107                 cp_error ("`%#D' redeclared as %C", old, form);
5108                 return NULL_TREE;
5109               }
5110             if (old)
5111               return old;
5112             if (thislevel_only || tail == global_namespace)
5113               return NULL_TREE;
5114           }
5115       else
5116         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5117           {
5118             if (TREE_PURPOSE (tail) == name)
5119               {
5120                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5121                 /* Should tighten this up; it'll probably permit
5122                    UNION_TYPE and a struct template, for example.  */
5123                 if (code != form
5124                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5125                   {
5126                     /* Definition isn't the kind we were looking for.  */
5127                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5128                               form);
5129                     return NULL_TREE;
5130                   }
5131                 return TREE_VALUE (tail);
5132               }
5133           }
5134       if (thislevel_only && ! level->tag_transparent)
5135         {
5136           if (level->template_parms_p && allow_template_parms_p)
5137             {
5138               /* We must deal with cases like this:
5139
5140                    template <class T> struct S;
5141                    template <class T> struct S {};
5142
5143                  When looking up `S', for the second declaration, we
5144                  would like to find the first declaration.  But, we
5145                  are in the pseudo-global level created for the
5146                  template parameters, rather than the (surrounding)
5147                  namespace level.  Thus, we keep going one more level,
5148                  even though THISLEVEL_ONLY is non-zero.  */
5149               allow_template_parms_p = 0;
5150               continue;
5151             }
5152           else
5153             return NULL_TREE;
5154         }
5155     }
5156   return NULL_TREE;
5157 }
5158
5159 #if 0
5160 void
5161 set_current_level_tags_transparency (tags_transparent)
5162      int tags_transparent;
5163 {
5164   current_binding_level->tag_transparent = tags_transparent;
5165 }
5166 #endif
5167
5168 /* Given a type, find the tag that was defined for it and return the tag name.
5169    Otherwise return 0.  However, the value can never be 0
5170    in the cases in which this is used.
5171
5172    C++: If NAME is non-zero, this is the new name to install.  This is
5173    done when replacing anonymous tags with real tag names.  */
5174
5175 static tree
5176 lookup_tag_reverse (type, name)
5177      tree type;
5178      tree name;
5179 {
5180   register struct binding_level *level;
5181
5182   for (level = current_binding_level; level; level = level->level_chain)
5183     {
5184       register tree tail;
5185       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5186         {
5187           if (TREE_VALUE (tail) == type)
5188             {
5189               if (name)
5190                 TREE_PURPOSE (tail) = name;
5191               return TREE_PURPOSE (tail);
5192             }
5193         }
5194     }
5195   return NULL_TREE;
5196 }
5197 \f
5198 /* Look up NAME in the NAMESPACE.  */
5199
5200 tree
5201 lookup_namespace_name (namespace, name)
5202      tree namespace, name;
5203 {
5204   tree val;
5205   tree template_id = NULL_TREE;
5206
5207   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5208
5209   if (TREE_CODE (name) == NAMESPACE_DECL)
5210     /* This happens for A::B<int> when B is a namespace. */
5211     return name;
5212   else if (TREE_CODE (name) == TEMPLATE_DECL)
5213     {
5214       /* This happens for A::B where B is a template, and there are no
5215          template arguments.  */
5216       cp_error ("invalid use of `%D'", name);
5217       return error_mark_node;
5218     }
5219
5220   namespace = ORIGINAL_NAMESPACE (namespace);
5221
5222   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5223     {
5224       template_id = name;
5225       name = TREE_OPERAND (name, 0);
5226       if (TREE_CODE (name) == OVERLOAD)
5227         name = DECL_NAME (OVL_CURRENT (name));
5228       else if (DECL_P (name))
5229         name = DECL_NAME (name);
5230     }
5231
5232   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5233
5234   val = make_node (CPLUS_BINDING);
5235   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5236     return error_mark_node;
5237
5238   if (BINDING_VALUE (val))
5239     {
5240       val = BINDING_VALUE (val);
5241
5242       if (template_id)
5243         {
5244           if (DECL_CLASS_TEMPLATE_P (val))
5245             val = lookup_template_class (val,
5246                                          TREE_OPERAND (template_id, 1),
5247                                          /*in_decl=*/NULL_TREE,
5248                                          /*context=*/NULL_TREE,
5249                                          /*entering_scope=*/0);
5250           else if (DECL_FUNCTION_TEMPLATE_P (val)
5251                    || TREE_CODE (val) == OVERLOAD)
5252             val = lookup_template_function (val,
5253                                             TREE_OPERAND (template_id, 1));
5254           else
5255             {
5256               cp_error ("`%D::%D' is not a template",
5257                         namespace, name);
5258               return error_mark_node;
5259             }
5260         }
5261
5262       /* If we have a single function from a using decl, pull it out.  */
5263       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5264         val = OVL_FUNCTION (val);
5265       return val;
5266     }
5267
5268   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5269   return error_mark_node;
5270 }
5271
5272 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5273
5274 static unsigned long
5275 typename_hash (k)
5276      hash_table_key k;
5277 {
5278   unsigned long hash;
5279   tree t;
5280
5281   t = (tree) k;
5282   hash = (((unsigned long) TYPE_CONTEXT (t))
5283           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5284
5285   return hash;
5286 }
5287
5288 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5289
5290 static boolean
5291 typename_compare (k1, k2)
5292      hash_table_key k1;
5293      hash_table_key k2;
5294 {
5295   tree t1;
5296   tree t2;
5297   tree d1;
5298   tree d2;
5299
5300   t1 = (tree) k1;
5301   t2 = (tree) k2;
5302   d1 = TYPE_NAME (t1);
5303   d2 = TYPE_NAME (t2);
5304
5305   return (DECL_NAME (d1) == DECL_NAME (d2)
5306           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5307           && ((TREE_TYPE (t1) != NULL_TREE)
5308               == (TREE_TYPE (t2) != NULL_TREE))
5309           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5310           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5311 }
5312
5313 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5314    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5315    is non-NULL, this type is being created by the implicit typename
5316    extension, and BASE_TYPE is a type named `t' in some base class of
5317    `T' which depends on template parameters.
5318
5319    Returns the new TYPENAME_TYPE.  */
5320
5321 tree
5322 build_typename_type (context, name, fullname, base_type)
5323      tree context;
5324      tree name;
5325      tree fullname;
5326      tree base_type;
5327 {
5328   tree t;
5329   tree d;
5330   struct hash_entry* e;
5331
5332   static struct hash_table ht;
5333
5334   if (!ht.table)
5335     {
5336       static struct hash_table *h = &ht;
5337       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5338                             &typename_compare))
5339         fatal ("virtual memory exhausted");
5340       ggc_add_tree_hash_table_root (&h, 1);
5341     }
5342
5343   /* Build the TYPENAME_TYPE.  */
5344   t = make_aggr_type (TYPENAME_TYPE);
5345   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5346   TYPENAME_TYPE_FULLNAME (t) = fullname;
5347   TREE_TYPE (t) = base_type;
5348
5349   /* Build the corresponding TYPE_DECL.  */
5350   d = build_decl (TYPE_DECL, name, t);
5351   TYPE_NAME (TREE_TYPE (d)) = d;
5352   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5353   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5354   DECL_ARTIFICIAL (d) = 1;
5355
5356   /* See if we already have this type.  */
5357   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5358   if (e)
5359     t = (tree) e->key;
5360   else
5361     /* Insert the type into the table.  */
5362     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5363
5364   return t;
5365 }
5366
5367 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5368    unless an error occurs, in which case error_mark_node is returned.
5369    If COMPLAIN zero, don't complain about any errors that occur.  */
5370
5371 tree
5372 make_typename_type (context, name, complain)
5373      tree context, name;
5374      int complain;
5375 {
5376   tree fullname;
5377
5378   if (TYPE_P (name))
5379     {
5380       if (!(TYPE_LANG_SPECIFIC (name)
5381             && (CLASSTYPE_IS_TEMPLATE (name)
5382                 || CLASSTYPE_USE_TEMPLATE (name))))
5383         name = TYPE_IDENTIFIER (name);
5384       else
5385         /* Create a TEMPLATE_ID_EXPR for the type.  */
5386         name = build_nt (TEMPLATE_ID_EXPR,
5387                          CLASSTYPE_TI_TEMPLATE (name),
5388                          CLASSTYPE_TI_ARGS (name));
5389     }
5390   else if (TREE_CODE (name) == TYPE_DECL)
5391     name = DECL_NAME (name);
5392
5393   fullname = name;
5394
5395   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5396     {
5397       name = TREE_OPERAND (name, 0);
5398       if (TREE_CODE (name) == TEMPLATE_DECL)
5399         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5400     }
5401   if (TREE_CODE (name) != IDENTIFIER_NODE)
5402     my_friendly_abort (2000);
5403
5404   if (TREE_CODE (context) == NAMESPACE_DECL)
5405     {
5406       /* We can get here from typename_sub0 in the explicit_template_type
5407          expansion.  Just fail.  */
5408       if (complain)
5409         cp_error ("no class template named `%#T' in `%#T'",
5410                   name, context);
5411       return error_mark_node;
5412     }
5413
5414   if (! uses_template_parms (context)
5415       || currently_open_class (context))
5416     {
5417       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5418         {
5419           tree tmpl = NULL_TREE;
5420           if (IS_AGGR_TYPE (context))
5421             tmpl = lookup_field (context, name, 0, 0);
5422           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5423             {
5424               if (complain)
5425                 cp_error ("no class template named `%#T' in `%#T'",
5426                           name, context);
5427               return error_mark_node;
5428             }
5429
5430           return lookup_template_class (tmpl,
5431                                         TREE_OPERAND (fullname, 1),
5432                                         NULL_TREE, context,
5433                                         /*entering_scope=*/0);
5434         }
5435       else
5436         {
5437           tree t;
5438
5439           if (!IS_AGGR_TYPE (context))
5440             {
5441               if (complain)
5442                 cp_error ("no type named `%#T' in `%#T'", name, context);
5443               return error_mark_node;
5444             }
5445
5446           t = lookup_field (context, name, 0, 1);
5447           if (t)
5448             return TREE_TYPE (t);
5449         }
5450     }
5451
5452   /* If the CONTEXT is not a template type, then either the field is
5453      there now or its never going to be.  */
5454   if (!uses_template_parms (context))
5455     {
5456       if (complain)
5457         cp_error ("no type named `%#T' in `%#T'", name, context);
5458       return error_mark_node;
5459     }
5460
5461
5462   return build_typename_type (context, name, fullname,  NULL_TREE);
5463 }
5464
5465 /* Select the right _DECL from multiple choices. */
5466
5467 static tree
5468 select_decl (binding, flags)
5469      tree binding;
5470      int flags;
5471 {
5472   tree val;
5473   val = BINDING_VALUE (binding);
5474   if (LOOKUP_NAMESPACES_ONLY (flags))
5475     {
5476       /* We are not interested in types. */
5477       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5478         return val;
5479       return NULL_TREE;
5480     }
5481
5482   /* If we could have a type and
5483      we have nothing or we need a type and have none.  */
5484   if (BINDING_TYPE (binding)
5485       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5486                    && TREE_CODE (val) != TYPE_DECL)))
5487     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5488   /* Don't return non-types if we really prefer types. */
5489   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5490            && (TREE_CODE (val) != TEMPLATE_DECL
5491                || !DECL_CLASS_TEMPLATE_P (val)))
5492     val = NULL_TREE;
5493
5494   return val;
5495 }
5496
5497 /* Unscoped lookup of a global: iterate over current namespaces,
5498    considering using-directives.  If SPACESP is non-NULL, store a list
5499    of the namespaces we've considered in it.  */
5500
5501 tree
5502 unqualified_namespace_lookup (name, flags, spacesp)
5503      tree name;
5504      int flags;
5505      tree *spacesp;
5506 {
5507   tree b = make_node (CPLUS_BINDING);
5508   tree initial = current_decl_namespace();
5509   tree scope = initial;
5510   tree siter;
5511   struct binding_level *level;
5512   tree val = NULL_TREE;
5513
5514   if (spacesp)
5515     *spacesp = NULL_TREE;
5516
5517   for (; !val; scope = CP_DECL_CONTEXT (scope))
5518     {
5519       if (spacesp)
5520         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5521       val = binding_for_name (name, scope);
5522
5523       /* Initialize binding for this context. */
5524       BINDING_VALUE (b) = BINDING_VALUE (val);
5525       BINDING_TYPE (b) = BINDING_TYPE (val);
5526
5527       /* Add all _DECLs seen through local using-directives. */
5528       for (level = current_binding_level;
5529            !level->namespace_p;
5530            level = level->level_chain)
5531         if (!lookup_using_namespace (name, b, level->using_directives,
5532                                      scope, flags, spacesp))
5533           /* Give up because of error. */
5534           return error_mark_node;
5535
5536       /* Add all _DECLs seen through global using-directives. */
5537       /* XXX local and global using lists should work equally. */
5538       siter = initial;
5539       while (1)
5540         {
5541           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5542                                        scope, flags, spacesp))
5543             /* Give up because of error. */
5544             return error_mark_node;
5545           if (siter == scope) break;
5546           siter = CP_DECL_CONTEXT (siter);
5547         }
5548
5549       val = select_decl (b, flags);
5550       if (scope == global_namespace)
5551         break;
5552     }
5553   return val;
5554 }
5555
5556 /* Combine prefer_type and namespaces_only into flags.  */
5557
5558 static int
5559 lookup_flags (prefer_type, namespaces_only)
5560   int prefer_type, namespaces_only;
5561 {
5562   if (namespaces_only)
5563     return LOOKUP_PREFER_NAMESPACES;
5564   if (prefer_type > 1)
5565     return LOOKUP_PREFER_TYPES;
5566   if (prefer_type > 0)
5567     return LOOKUP_PREFER_BOTH;
5568   return 0;
5569 }
5570
5571 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5572    ignore it or not.  Subroutine of lookup_name_real.  */
5573
5574 static tree
5575 qualify_lookup (val, flags)
5576      tree val;
5577      int flags;
5578 {
5579   if (val == NULL_TREE)
5580     return val;
5581   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5582     return val;
5583   if ((flags & LOOKUP_PREFER_TYPES)
5584       && (TREE_CODE (val) == TYPE_DECL
5585           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5586               && DECL_CLASS_TEMPLATE_P (val))))
5587     return val;
5588   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5589     return NULL_TREE;
5590   return val;
5591 }
5592
5593 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5594    that.  */
5595
5596 static void
5597 warn_about_implicit_typename_lookup (typename, binding)
5598      tree typename;
5599      tree binding;
5600 {
5601   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5602   tree name = DECL_NAME (typename);
5603
5604   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5605          && CLASSTYPE_TEMPLATE_INFO (subtype)
5606          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5607       && ! (TREE_CODE (binding) == TYPE_DECL
5608             && same_type_p (TREE_TYPE (binding), subtype)))
5609     {
5610       cp_warning ("lookup of `%D' finds `%#D'",
5611                   name, binding);
5612       cp_warning ("  instead of `%D' from dependent base class",
5613                   typename);
5614       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5615                   constructor_name (current_class_type), name);
5616     }
5617 }
5618
5619 /* Look up NAME in the current binding level and its superiors in the
5620    namespace of variables, functions and typedefs.  Return a ..._DECL
5621    node of some kind representing its definition if there is only one
5622    such declaration, or return a TREE_LIST with all the overloaded
5623    definitions if there are many, or return 0 if it is undefined.
5624
5625    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5626    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5627    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5628    Otherwise we prefer non-TYPE_DECLs.
5629
5630    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5631    using IDENTIFIER_CLASS_VALUE.  */
5632
5633 static tree
5634 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5635      tree name;
5636      int prefer_type, nonclass, namespaces_only;
5637 {
5638   tree t;
5639   tree val = NULL_TREE;
5640   int yylex = 0;
5641   tree from_obj = NULL_TREE;
5642   int flags;
5643   int val_is_implicit_typename = 0;
5644
5645   /* Hack: copy flag set by parser, if set. */
5646   if (only_namespace_names)
5647     namespaces_only = 1;
5648
5649   if (prefer_type == -2)
5650     {
5651       extern int looking_for_typename;
5652       tree type = NULL_TREE;
5653
5654       yylex = 1;
5655       prefer_type = looking_for_typename;
5656
5657       flags = lookup_flags (prefer_type, namespaces_only);
5658       /* If the next thing is '<', class templates are types. */
5659       if (looking_for_template)
5660         flags |= LOOKUP_TEMPLATES_EXPECTED;
5661
5662       /* std:: becomes :: for now.  */
5663       if (got_scope == std_node)
5664         got_scope = void_type_node;
5665
5666       if (got_scope)
5667         type = got_scope;
5668       else if (got_object != error_mark_node)
5669         type = got_object;
5670
5671       if (type)
5672         {
5673           if (type == error_mark_node)
5674             return error_mark_node;
5675           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5676             type = TREE_TYPE (type);
5677
5678           if (TYPE_P (type))
5679             type = complete_type (type);
5680
5681           if (TREE_CODE (type) == VOID_TYPE)
5682             type = global_namespace;
5683           if (TREE_CODE (type) == NAMESPACE_DECL)
5684             {
5685               val = make_node (CPLUS_BINDING);
5686               flags |= LOOKUP_COMPLAIN;
5687               if (!qualified_lookup_using_namespace (name, type, val, flags))
5688                 return NULL_TREE;
5689               val = select_decl (val, flags);
5690             }
5691           else if (! IS_AGGR_TYPE (type)
5692                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5693                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5694                    || TREE_CODE (type) == TYPENAME_TYPE)
5695             /* Someone else will give an error about this if needed.  */
5696             val = NULL_TREE;
5697           else if (type == current_class_type)
5698             val = IDENTIFIER_CLASS_VALUE (name);
5699           else
5700             {
5701               val = lookup_member (type, name, 0, prefer_type);
5702               type_access_control (type, val);
5703             }
5704         }
5705       else
5706         val = NULL_TREE;
5707
5708       if (got_scope)
5709         goto done;
5710       else if (got_object && val)
5711         from_obj = val;
5712     }
5713   else
5714     {
5715       flags = lookup_flags (prefer_type, namespaces_only);
5716       /* If we're not parsing, we need to complain. */
5717       flags |= LOOKUP_COMPLAIN;
5718     }
5719
5720   /* First, look in non-namespace scopes.  */
5721
5722   if (current_class_type == NULL_TREE)
5723     nonclass = 1;
5724
5725   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5726     {
5727       tree binding;
5728
5729       if (!LOCAL_BINDING_P (t) && nonclass)
5730         /* We're not looking for class-scoped bindings, so keep going.  */
5731         continue;
5732
5733       /* If this is the kind of thing we're looking for, we're done.  */
5734       if (qualify_lookup (BINDING_VALUE (t), flags))
5735         binding = BINDING_VALUE (t);
5736       else if ((flags & LOOKUP_PREFER_TYPES)
5737                && qualify_lookup (BINDING_TYPE (t), flags))
5738         binding = BINDING_TYPE (t);
5739       else
5740         binding = NULL_TREE;
5741
5742       /* Handle access control on types from enclosing or base classes.  */
5743       if (binding && ! yylex
5744           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5745         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5746
5747       if (binding
5748           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5749         {
5750           if (val_is_implicit_typename && !yylex)
5751             warn_about_implicit_typename_lookup (val, binding);
5752           val = binding;
5753           val_is_implicit_typename
5754             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5755           if (!val_is_implicit_typename)
5756             break;
5757         }
5758     }
5759
5760   /* Now lookup in namespace scopes.  */
5761   if (!val || val_is_implicit_typename)
5762     {
5763       t = unqualified_namespace_lookup (name, flags, 0);
5764       if (t)
5765         {
5766           if (val_is_implicit_typename && !yylex)
5767             warn_about_implicit_typename_lookup (val, t);
5768           val = t;
5769         }
5770     }
5771
5772  done:
5773   if (val)
5774     {
5775       /* This should only warn about types used in qualified-ids.  */
5776       if (from_obj && from_obj != val)
5777         {
5778           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5779               && TREE_CODE (val) == TYPE_DECL
5780               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5781             {
5782               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5783                           name, got_object, TREE_TYPE (from_obj));
5784               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5785                           TREE_TYPE (val));
5786             }
5787
5788           /* We don't change val to from_obj if got_object depends on
5789              template parms because that breaks implicit typename for
5790              destructor calls.  */
5791           if (! uses_template_parms (got_object))
5792             val = from_obj;
5793         }
5794
5795       /* If we have a single function from a using decl, pull it out.  */
5796       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5797         val = OVL_FUNCTION (val);
5798     }
5799   else if (from_obj)
5800     val = from_obj;
5801
5802   return val;
5803 }
5804
5805 tree
5806 lookup_name_nonclass (name)
5807      tree name;
5808 {
5809   return lookup_name_real (name, 0, 1, 0);
5810 }
5811
5812 tree
5813 lookup_function_nonclass (name, args)
5814      tree name;
5815      tree args;
5816 {
5817   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5818 }
5819
5820 tree
5821 lookup_name_namespace_only (name)
5822      tree name;
5823 {
5824   /* type-or-namespace, nonclass, namespace_only */
5825   return lookup_name_real (name, 1, 1, 1);
5826 }
5827
5828 tree
5829 lookup_name (name, prefer_type)
5830      tree name;
5831      int prefer_type;
5832 {
5833   return lookup_name_real (name, prefer_type, 0, 0);
5834 }
5835
5836 /* Similar to `lookup_name' but look only in the innermost non-class
5837    binding level.  */
5838
5839 tree
5840 lookup_name_current_level (name)
5841      tree name;
5842 {
5843   struct binding_level *b;
5844   tree t = NULL_TREE;
5845
5846   b = current_binding_level;
5847   while (b->parm_flag == 2)
5848     b = b->level_chain;
5849
5850   if (b->namespace_p)
5851     {
5852       t = IDENTIFIER_NAMESPACE_VALUE (name);
5853
5854       /* extern "C" function() */
5855       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5856         t = TREE_VALUE (t);
5857     }
5858   else if (IDENTIFIER_BINDING (name)
5859            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
5860     {
5861       while (1)
5862         {
5863           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
5864             return IDENTIFIER_VALUE (name);
5865
5866           if (b->keep == 2)
5867             b = b->level_chain;
5868           else
5869             break;
5870         }
5871     }
5872
5873   return t;
5874 }
5875
5876 /* Like lookup_name_current_level, but for types.  */
5877
5878 tree
5879 lookup_type_current_level (name)
5880      tree name;
5881 {
5882   register tree t = NULL_TREE;
5883
5884   my_friendly_assert (! current_binding_level->namespace_p, 980716);
5885
5886   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5887       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5888     {
5889       struct binding_level *b = current_binding_level;
5890       while (1)
5891         {
5892           if (purpose_member (name, b->type_shadowed))
5893             return REAL_IDENTIFIER_TYPE_VALUE (name);
5894           if (b->keep == 2)
5895             b = b->level_chain;
5896           else
5897             break;
5898         }
5899     }
5900
5901   return t;
5902 }
5903
5904 void
5905 begin_only_namespace_names ()
5906 {
5907   only_namespace_names = 1;
5908 }
5909
5910 void
5911 end_only_namespace_names ()
5912 {
5913   only_namespace_names = 0;
5914 }
5915 \f
5916 /* Arrange for the user to get a source line number, even when the
5917    compiler is going down in flames, so that she at least has a
5918    chance of working around problems in the compiler.  We used to
5919    call error(), but that let the segmentation fault continue
5920    through; now, it's much more passive by asking them to send the
5921    maintainers mail about the problem.  */
5922
5923 static void
5924 signal_catch (sig)
5925      int sig ATTRIBUTE_UNUSED;
5926 {
5927   signal (SIGSEGV, SIG_DFL);
5928 #ifdef SIGIOT
5929   signal (SIGIOT, SIG_DFL);
5930 #endif
5931 #ifdef SIGILL
5932   signal (SIGILL, SIG_DFL);
5933 #endif
5934 #ifdef SIGABRT
5935   signal (SIGABRT, SIG_DFL);
5936 #endif
5937 #ifdef SIGBUS
5938   signal (SIGBUS, SIG_DFL);
5939 #endif
5940   my_friendly_abort (0);
5941 }
5942
5943 /* Push the declarations of builtin types into the namespace.
5944    RID_INDEX, if < RID_MAX is the index of the builtin type
5945    in the array RID_POINTERS.  NAME is the name used when looking
5946    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
5947
5948 static void
5949 record_builtin_type (rid_index, name, type)
5950      enum rid rid_index;
5951      const char *name;
5952      tree type;
5953 {
5954   tree rname = NULL_TREE, tname = NULL_TREE;
5955   tree tdecl = NULL_TREE;
5956
5957   if ((int) rid_index < (int) RID_MAX)
5958     rname = ridpointers[(int) rid_index];
5959   if (name)
5960     tname = get_identifier (name);
5961
5962   TYPE_BUILT_IN (type) = 1;
5963
5964   if (tname)
5965     {
5966       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5967       set_identifier_type_value (tname, NULL_TREE);
5968       if ((int) rid_index < (int) RID_MAX)
5969         /* Built-in types live in the global namespace. */
5970         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5971     }
5972   if (rname != NULL_TREE)
5973     {
5974       if (tname != NULL_TREE)
5975         {
5976           set_identifier_type_value (rname, NULL_TREE);
5977           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5978         }
5979       else
5980         {
5981           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5982           set_identifier_type_value (rname, NULL_TREE);
5983         }
5984     }
5985 }
5986
5987 /* Record one of the standard Java types.
5988  * Declare it as having the given NAME.
5989  * If SIZE > 0, it is the size of one of the integral types;
5990  * otherwise it is the negative of the size of one of the other types.  */
5991
5992 static tree
5993 record_builtin_java_type (name, size)
5994      const char *name;
5995      int size;
5996 {
5997   tree type, decl;
5998   if (size > 0)
5999     type = make_signed_type (size);
6000   else if (size > -32)
6001     { /* "__java_char" or ""__java_boolean". */
6002       type = make_unsigned_type (-size);
6003       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6004     }
6005   else
6006     { /* "__java_float" or ""__java_double". */
6007       type = make_node (REAL_TYPE);
6008       TYPE_PRECISION (type) = - size;
6009       layout_type (type);
6010     }
6011   record_builtin_type (RID_MAX, name, type);
6012   decl = TYPE_NAME (type);
6013
6014   /* Suppress generate debug symbol entries for these types,
6015      since for normal C++ they are just clutter.
6016      However, push_lang_context undoes this if extern "Java" is seen. */
6017   DECL_IGNORED_P (decl) = 1;
6018
6019   TYPE_FOR_JAVA (type) = 1;
6020   return type;
6021 }
6022
6023 /* Push a type into the namespace so that the back-ends ignore it. */
6024
6025 static void
6026 record_unknown_type (type, name)
6027      tree type;
6028      const char *name;
6029 {
6030   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6031   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6032   DECL_IGNORED_P (decl) = 1;
6033   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6034   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6035   TYPE_ALIGN (type) = 1;
6036   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6037 }
6038
6039 /* An string for which we should create an IDENTIFIER_NODE at
6040    startup.  */
6041
6042 typedef struct predefined_identifier
6043 {
6044   /* The name of the identifier.  */
6045   const char *name;
6046   /* The place where the IDENTIFIER_NODE should be stored.  */
6047   tree *node;
6048 } predefined_identifier;
6049
6050 /* Create all the predefined identifiers.  */
6051
6052 static void
6053 initialize_predefined_identifiers ()
6054 {
6055   struct predefined_identifier *pid;
6056
6057   /* A table of identifiers to create at startup.  */
6058   static predefined_identifier predefined_identifiers[] = {
6059     { "C++", &lang_name_cplusplus },
6060     { "C", &lang_name_c },
6061     { "Java", &lang_name_java },
6062     { CTOR_NAME, &ctor_identifier },
6063     { "__base_ctor", &base_ctor_identifier },
6064     { "__comp_ctor", &complete_ctor_identifier },
6065     { DTOR_NAME, &dtor_identifier },
6066     { "__base_dtor", &base_dtor_identifier },
6067     { "__deleting_dtor", &deleting_dtor_identifier },
6068     { VTABLE_DELTA2_NAME, &delta2_identifier },
6069     { VTABLE_DELTA_NAME, &delta_identifier },
6070     { IN_CHARGE_NAME, &in_charge_identifier },
6071     { VTABLE_INDEX_NAME, &index_identifier },
6072     { "nelts", &nelts_identifier },
6073     { THIS_NAME, &this_identifier },
6074     { VTABLE_PFN_NAME, &pfn_identifier },
6075     { "__pfn_or_delta2", &pfn_or_delta2_identifier },
6076     { "_vptr", &vptr_identifier },
6077     { NULL, NULL }
6078   };
6079
6080   for (pid = predefined_identifiers; pid->name; ++pid)
6081     *pid->node = get_identifier (pid->name);
6082 }
6083
6084 /* Create the predefined scalar types of C,
6085    and some nodes representing standard constants (0, 1, (void *)0).
6086    Initialize the global binding level.
6087    Make definitions for built-in primitive functions.  */
6088
6089 void
6090 init_decl_processing ()
6091 {
6092   tree fields[20];
6093   int wchar_type_size;
6094   tree array_domain_type;
6095
6096   /* Check to see that the user did not specify an invalid combination
6097      of command-line options.  */
6098   if (flag_new_abi && !flag_vtable_thunks)
6099     fatal ("the new ABI requires vtable thunks");
6100
6101   /* Create all the identifiers we need.  */
6102   initialize_predefined_identifiers ();
6103
6104   /* Let the back-end now how to save and restore language-specific
6105      per-function globals.  */
6106   init_lang_status = &push_cp_function_context;
6107   free_lang_status = &pop_cp_function_context;
6108   mark_lang_status = &mark_cp_function_context;
6109
6110   cp_parse_init ();
6111   init_decl2 ();
6112   init_pt ();
6113
6114   /* Create the global variables.  */
6115   push_to_top_level ();
6116
6117   /* Enter the global namespace. */
6118   my_friendly_assert (global_namespace == NULL_TREE, 375);
6119   push_namespace (get_identifier ("::"));
6120   global_namespace = current_namespace;
6121   current_lang_name = NULL_TREE;
6122
6123   /* Adjust various flags based on command-line settings.  */
6124   if (flag_strict_prototype == 2)
6125     flag_strict_prototype = pedantic;
6126   if (! flag_permissive && ! pedantic)
6127     flag_pedantic_errors = 1;
6128   if (!flag_no_inline)
6129     flag_inline_trees = 1;
6130
6131   strict_prototypes_lang_c = flag_strict_prototype;
6132
6133   /* Initially, C.  */
6134   current_lang_name = lang_name_c;
6135
6136   current_function_decl = NULL_TREE;
6137   current_binding_level = NULL_BINDING_LEVEL;
6138   free_binding_level = NULL_BINDING_LEVEL;
6139
6140   /* Because most segmentation signals can be traced back into user
6141      code, catch them and at least give the user a chance of working
6142      around compiler bugs.  */
6143   signal (SIGSEGV, signal_catch);
6144
6145   /* We will also catch aborts in the back-end through signal_catch and
6146      give the user a chance to see where the error might be, and to defeat
6147      aborts in the back-end when there have been errors previously in their
6148      code.  */
6149 #ifdef SIGIOT
6150   signal (SIGIOT, signal_catch);
6151 #endif
6152 #ifdef SIGILL
6153   signal (SIGILL, signal_catch);
6154 #endif
6155 #ifdef SIGABRT
6156   signal (SIGABRT, signal_catch);
6157 #endif
6158 #ifdef SIGBUS
6159   signal (SIGBUS, signal_catch);
6160 #endif
6161
6162   build_common_tree_nodes (flag_signed_char);
6163
6164   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6165   TREE_TYPE (error_mark_list) = error_mark_node;
6166
6167   /* Make the binding_level structure for global names.  */
6168   pushlevel (0);
6169   global_binding_level = current_binding_level;
6170   /* The global level is the namespace level of ::.  */
6171   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6172   declare_namespace_level ();
6173
6174   /* Define `int' and `char' first so that dbx will output them first.  */
6175   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6176   record_builtin_type (RID_CHAR, "char", char_type_node);
6177
6178   /* `signed' is the same as `int' */
6179   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6180   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6181   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6182   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6183   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6184   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6185   record_builtin_type (RID_MAX, "long long unsigned int",
6186                        long_long_unsigned_type_node);
6187   record_builtin_type (RID_MAX, "long long unsigned",
6188                        long_long_unsigned_type_node);
6189   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6190   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6191   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6192
6193   ptrdiff_type_node
6194     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6195
6196   /* Define both `signed char' and `unsigned char'.  */
6197   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6198   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6199
6200   /* `unsigned long' is the standard type for sizeof.
6201      Note that stddef.h uses `unsigned long',
6202      and this must agree, even if long and int are the same size.  */
6203   set_sizetype
6204     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6205
6206   /* Create the widest literal types. */
6207   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6208   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6209                         widest_integer_literal_type_node));
6210
6211   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6212   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6213                         widest_unsigned_literal_type_node));
6214
6215   /* These are types that type_for_size and type_for_mode use.  */
6216   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6217   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6218   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6219   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6220 #if HOST_BITS_PER_WIDE_INT >= 64
6221   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6222 #endif
6223   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6224   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6225   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6226   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6227 #if HOST_BITS_PER_WIDE_INT >= 64
6228   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6229 #endif
6230
6231   build_common_tree_nodes_2 (flag_short_double);
6232
6233   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6234   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6235   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6236   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6237   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6238   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6239   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6240   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6241
6242   integer_two_node = build_int_2 (2, 0);
6243   TREE_TYPE (integer_two_node) = integer_type_node;
6244   integer_three_node = build_int_2 (3, 0);
6245   TREE_TYPE (integer_three_node) = integer_type_node;
6246
6247   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6248   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6249   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6250   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6251   TYPE_PRECISION (boolean_type_node) = 1;
6252   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6253   boolean_false_node = build_int_2 (0, 0);
6254   TREE_TYPE (boolean_false_node) = boolean_type_node;
6255   boolean_true_node = build_int_2 (1, 0);
6256   TREE_TYPE (boolean_true_node) = boolean_type_node;
6257
6258   signed_size_zero_node = build_int_2 (0, 0);
6259   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6260   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6261   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6262
6263   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6264                         complex_integer_type_node));
6265   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6266                         complex_float_type_node));
6267   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6268                         complex_double_type_node));
6269   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6270                         complex_long_double_type_node));
6271
6272   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6273
6274   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6275   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6276   TREE_PARMLIST (void_list_node) = 1;
6277
6278   /* Used for expressions that do nothing, but are not errors.  */
6279   void_zero_node = build_int_2 (0, 0);
6280   TREE_TYPE (void_zero_node) = void_type_node;
6281
6282   string_type_node = build_pointer_type (char_type_node);
6283   const_string_type_node
6284     = build_pointer_type (build_qualified_type (char_type_node,
6285                                                 TYPE_QUAL_CONST));
6286   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6287 #if 0
6288   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6289 #endif
6290
6291   /* Make a type to be the domain of a few array types
6292      whose domains don't really matter.
6293      200 is small enough that it always fits in size_t.  */
6294   array_domain_type = build_index_type (build_int_2 (200, 0));
6295
6296   /* Make a type for arrays of characters.
6297      With luck nothing will ever really depend on the length of this
6298      array type.  */
6299   char_array_type_node
6300     = build_array_type (char_type_node, array_domain_type);
6301   /* Likewise for arrays of ints.  */
6302   int_array_type_node
6303     = build_array_type (integer_type_node, array_domain_type);
6304
6305   if (flag_new_abi)
6306     delta_type_node = ptrdiff_type_node;
6307   else if (flag_huge_objects)
6308     delta_type_node = long_integer_type_node;
6309   else
6310     delta_type_node = short_integer_type_node;
6311
6312   if (flag_new_abi)
6313     vtable_index_type = ptrdiff_type_node;
6314   else
6315     vtable_index_type = delta_type_node;
6316
6317   default_function_type
6318     = build_function_type (integer_type_node, NULL_TREE);
6319
6320   ptr_type_node = build_pointer_type (void_type_node);
6321   const_ptr_type_node
6322     = build_pointer_type (build_qualified_type (void_type_node,
6323                                                 TYPE_QUAL_CONST));
6324   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6325   lang_type_promotes_to = convert_type_from_ellipsis;
6326
6327   void_ftype_ptr
6328     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6329
6330   /* C++ extensions */
6331
6332   unknown_type_node = make_node (UNKNOWN_TYPE);
6333   record_unknown_type (unknown_type_node, "unknown type");
6334
6335   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6336   TREE_TYPE (unknown_type_node) = unknown_type_node;
6337
6338   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6339
6340   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6341      result.  */
6342   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6343   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6344
6345   /* This is special for C++ so functions can be overloaded.  */
6346   wchar_type_node = get_identifier (flag_short_wchar
6347                                     ? "short unsigned int"
6348                                     : WCHAR_TYPE);
6349   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6350   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6351   signed_wchar_type_node = make_signed_type (wchar_type_size);
6352   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6353   wchar_type_node
6354     = TREE_UNSIGNED (wchar_type_node)
6355       ? unsigned_wchar_type_node
6356       : signed_wchar_type_node;
6357   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6358
6359   /* Artificial declaration of wchar_t -- can be bashed */
6360   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6361                                 wchar_type_node);
6362   pushdecl (wchar_decl_node);
6363
6364   /* This is for wide string constants.  */
6365   wchar_array_type_node
6366     = build_array_type (wchar_type_node, array_domain_type);
6367
6368   if (flag_vtable_thunks)
6369     {
6370       /* Make sure we get a unique function type, so we can give
6371          its pointer type a name.  (This wins for gdb.) */
6372       tree vfunc_type = make_node (FUNCTION_TYPE);
6373       TREE_TYPE (vfunc_type) = integer_type_node;
6374       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6375       layout_type (vfunc_type);
6376
6377       vtable_entry_type = build_pointer_type (vfunc_type);
6378     }
6379   else
6380     {
6381       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6382       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
6383                                    delta_type_node);
6384       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
6385                                    delta_type_node);
6386       fields[2] = build_lang_decl (FIELD_DECL, pfn_identifier,
6387                                    ptr_type_node);
6388       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6389                            double_type_node);
6390
6391       /* Make this part of an invisible union.  */
6392       fields[3] = copy_node (fields[2]);
6393       TREE_TYPE (fields[3]) = delta_type_node;
6394       DECL_NAME (fields[3]) = delta2_identifier;
6395       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6396       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6397       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6398       TREE_UNSIGNED (fields[3]) = 0;
6399       TREE_CHAIN (fields[2]) = fields[3];
6400       vtable_entry_type = build_qualified_type (vtable_entry_type,
6401                                                 TYPE_QUAL_CONST);
6402     }
6403   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6404
6405   vtbl_type_node
6406     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6407   layout_type (vtbl_type_node);
6408   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6409   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6410   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6411   layout_type (vtbl_ptr_type_node);
6412   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6413
6414   std_node = build_decl (NAMESPACE_DECL,
6415                          get_identifier (flag_honor_std ? "fake std":"std"),
6416                          void_type_node);
6417   pushdecl (std_node);
6418
6419   if (flag_new_abi)
6420     {
6421       push_namespace (get_identifier ("__cxxabiv1"));
6422       abi_node = current_namespace;
6423       pop_namespace ();
6424     }
6425
6426   global_type_node = make_node (LANG_TYPE);
6427   record_unknown_type (global_type_node, "global type");
6428
6429   /* Now, C++.  */
6430   current_lang_name = lang_name_cplusplus;
6431
6432   {
6433     tree bad_alloc_type_node, newtype, deltype;
6434     if (flag_honor_std)
6435       push_namespace (get_identifier ("std"));
6436     bad_alloc_type_node = xref_tag
6437       (class_type_node, get_identifier ("bad_alloc"), 1);
6438     if (flag_honor_std)
6439       pop_namespace ();
6440     newtype = build_exception_variant
6441       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6442     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6443     push_cp_library_fn (ansi_opname[(int) NEW_EXPR], newtype);
6444     push_cp_library_fn (ansi_opname[(int) VEC_NEW_EXPR], newtype);
6445     global_delete_fndecl = push_cp_library_fn (ansi_opname[(int) DELETE_EXPR],
6446                                                deltype);
6447     push_cp_library_fn (ansi_opname[(int) VEC_DELETE_EXPR], deltype);
6448   }
6449
6450   abort_fndecl
6451     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6452
6453   /* Perform other language dependent initializations.  */
6454   init_class_processing ();
6455   init_init_processing ();
6456   init_search_processing ();
6457   init_rtti_processing ();
6458
6459   if (flag_exceptions)
6460     init_exception_processing ();
6461   if (flag_no_inline)
6462     {
6463       flag_inline_functions = 0;
6464     }
6465
6466   if (! supports_one_only ())
6467     flag_weak = 0;
6468
6469   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6470   make_fname_decl = cp_make_fname_decl;
6471   declare_function_name ();
6472
6473   /* Prepare to check format strings against argument lists.  */
6474   init_function_format_info ();
6475
6476   /* Show we use EH for cleanups.  */
6477   using_eh_for_cleanups ();
6478
6479   print_error_function = lang_print_error_function;
6480   lang_get_alias_set = &c_get_alias_set;
6481   valid_lang_attribute = cp_valid_lang_attribute;
6482
6483   /* Maintain consistency.  Perhaps we should just complain if they
6484      say -fwritable-strings?  */
6485   if (flag_writable_strings)
6486     flag_const_strings = 0;
6487
6488   /* Add GC roots for all of our global variables.  */
6489   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6490   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6491   ggc_add_tree_root (&integer_three_node, 1);
6492   ggc_add_tree_root (&integer_two_node, 1);
6493   ggc_add_tree_root (&signed_size_zero_node, 1);
6494   ggc_add_tree_root (&size_one_node, 1);
6495   ggc_add_tree_root (&size_zero_node, 1);
6496   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6497                 mark_binding_level);
6498   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6499   ggc_add_tree_root (&static_ctors, 1);
6500   ggc_add_tree_root (&static_dtors, 1);
6501   ggc_add_tree_root (&lastiddecl, 1);
6502
6503   ggc_add_tree_root (&last_function_parm_tags, 1);
6504   ggc_add_tree_root (&current_function_return_value, 1);
6505   ggc_add_tree_root (&current_function_parms, 1);
6506   ggc_add_tree_root (&current_function_parm_tags, 1);
6507   ggc_add_tree_root (&last_function_parms, 1);
6508   ggc_add_tree_root (&error_mark_list, 1);
6509
6510   ggc_add_tree_root (&global_namespace, 1);
6511   ggc_add_tree_root (&global_type_node, 1);
6512   ggc_add_tree_root (&anonymous_namespace_name, 1);
6513
6514   ggc_add_tree_root (&got_object, 1);
6515   ggc_add_tree_root (&got_scope, 1);
6516
6517   ggc_add_tree_root (&current_lang_name, 1);
6518   ggc_add_tree_root (&static_aggregates, 1);
6519 }
6520
6521 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6522    decl, NAME is the initialization string and TYPE_DEP indicates whether
6523    NAME depended on the type of the function. We make use of that to detect
6524    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6525    the function before emitting any of it, we don't need to treat the
6526    VAR_DECL specially. We can decide whether to emit it later, if it was
6527    used.  */
6528
6529 static tree
6530 cp_make_fname_decl (id, name, type_dep)
6531      tree id;
6532      const char *name;
6533      int type_dep;
6534 {
6535   tree decl, type, init;
6536   size_t length = strlen (name);
6537   tree domain = NULL_TREE;
6538
6539   if (!processing_template_decl)
6540     type_dep = 0;
6541   if (!type_dep)
6542     domain = build_index_type (build_int_2 (length, 0));
6543
6544   type =  build_cplus_array_type
6545           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6546            domain);
6547
6548   decl = build_lang_decl (VAR_DECL, id, type);
6549   TREE_STATIC (decl) = 1;
6550   TREE_READONLY (decl) = 1;
6551   DECL_SOURCE_LINE (decl) = 0;
6552   DECL_ARTIFICIAL (decl) = 1;
6553   DECL_IN_SYSTEM_HEADER (decl) = 1;
6554   pushdecl (decl);
6555   if (processing_template_decl)
6556     decl = push_template_decl (decl);
6557   if (type_dep)
6558     {
6559       init = build (FUNCTION_NAME, type);
6560       DECL_PRETTY_FUNCTION_P (decl) = 1;
6561     }
6562   else
6563     {
6564       init = build_string (length + 1, name);
6565       TREE_TYPE (init) = type;
6566     }
6567   DECL_INITIAL (decl) = init;
6568   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6569
6570   /* We will have to make sure we only emit this, if it is actually used. */
6571   return decl;
6572 }
6573
6574 /* Function to print any language-specific context for an error message.  */
6575
6576 static void
6577 lang_print_error_function (file)
6578      const char *file;
6579 {
6580   default_print_error_function (file);
6581   maybe_print_template_context ();
6582 }
6583
6584 /* Entry point for the benefit of c_common_nodes_and_builtins.
6585
6586    Make a definition for a builtin function named NAME and whose data type
6587    is TYPE.  TYPE should be a function type with argument types.
6588
6589    CLASS and CODE tell later passes how to compile calls to this function.
6590    See tree.h for possible values.
6591
6592    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6593    the name to be called if we can't opencode the function.  */
6594
6595 tree
6596 builtin_function (name, type, code, class, libname)
6597      const char *name;
6598      tree type;
6599      int code;
6600      enum built_in_class class;
6601      const char *libname;
6602 {
6603   tree decl = build_library_fn_1 (get_identifier (name), type);
6604   DECL_BUILT_IN_CLASS (decl) = class;
6605   DECL_FUNCTION_CODE (decl) = code;
6606
6607   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6608
6609   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6610      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6611      function in the namespace.  */
6612   pushdecl (decl);
6613   if (libname)
6614     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6615   make_function_rtl (decl);
6616   return decl;
6617 }
6618
6619 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6620    function.  Not called directly.  */
6621
6622 static tree
6623 build_library_fn_1 (name, type)
6624      tree name;
6625      tree type;
6626 {
6627   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6628   DECL_EXTERNAL (fn) = 1;
6629   TREE_PUBLIC (fn) = 1;
6630   DECL_ARTIFICIAL (fn) = 1;
6631   TREE_NOTHROW (fn) = 1;
6632   return fn;
6633 }
6634
6635 /* Returns the _DECL for a library function with C linkage.
6636    We assume that such functions never throw; if this is incorrect,
6637    callers should unset TREE_NOTHROW.  */
6638
6639 tree
6640 build_library_fn (name, type)
6641      tree name;
6642      tree type;
6643 {
6644   tree fn = build_library_fn_1 (name, type);
6645   make_function_rtl (fn);
6646   return fn;
6647 }
6648
6649 /* Returns the _DECL for a library function with C++ linkage.  */
6650
6651 tree
6652 build_cp_library_fn (name, type)
6653      tree name;
6654      tree type;
6655 {
6656   tree fn = build_library_fn_1 (name, type);
6657   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6658   set_mangled_name_for_decl (fn);
6659   make_function_rtl (fn);
6660   return fn;
6661 }
6662
6663 /* Like build_library_fn, but takes a C string instead of an
6664    IDENTIFIER_NODE.  */
6665
6666 tree
6667 build_library_fn_ptr (name, type)
6668      const char *name;
6669      tree type;
6670 {
6671   return build_library_fn (get_identifier (name), type);
6672 }
6673
6674 /* Like build_cp_library_fn, but takes a C string instead of an
6675    IDENTIFIER_NODE.  */
6676
6677 tree
6678 build_cp_library_fn_ptr (name, type)
6679      const char *name;
6680      tree type;
6681 {
6682   return build_cp_library_fn (get_identifier (name), type);
6683 }
6684
6685 /* Like build_library_fn, but also pushes the function so that we will
6686    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6687
6688 tree
6689 push_library_fn (name, type)
6690      tree name, type;
6691 {
6692   tree fn = build_library_fn (name, type);
6693   pushdecl_top_level (fn);
6694   return fn;
6695 }
6696
6697 /* Like build_cp_library_fn, but also pushes the function so that it
6698    will be found by normal lookup.  */
6699
6700 tree
6701 push_cp_library_fn (name, type)
6702      tree name;
6703      tree type;
6704 {
6705   tree fn = build_cp_library_fn (name, type);
6706   pushdecl (fn);
6707   return fn;
6708 }
6709
6710 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6711    a FUNCTION_TYPE.  */
6712
6713 tree
6714 push_void_library_fn (name, parmtypes)
6715      tree name, parmtypes;
6716 {
6717   tree type = build_function_type (void_type_node, parmtypes);
6718   return push_library_fn (name, type);
6719 }
6720
6721 /* Like push_library_fn, but also note that this function throws
6722    and does not return.  Used for __throw_foo and the like.  */
6723
6724 tree
6725 push_throw_library_fn (name, type)
6726      tree name, type;
6727 {
6728   tree fn = push_library_fn (name, type);
6729   TREE_THIS_VOLATILE (fn) = 1;
6730   TREE_NOTHROW (fn) = 0;
6731   return fn;
6732 }
6733 \f
6734 /* When we call finish_struct for an anonymous union, we create
6735    default copy constructors and such.  But, an anonymous union
6736    shouldn't have such things; this function undoes the damage to the
6737    anonymous union type T.
6738
6739    (The reason that we create the synthesized methods is that we don't
6740    distinguish `union { int i; }' from `typedef union { int i; } U'.
6741    The first is an anonymous union; the second is just an ordinary
6742    union type.)  */
6743
6744 void
6745 fixup_anonymous_aggr (t)
6746      tree t;
6747 {
6748   tree *q;
6749
6750   /* Wipe out memory of synthesized methods */
6751   TYPE_HAS_CONSTRUCTOR (t) = 0;
6752   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6753   TYPE_HAS_INIT_REF (t) = 0;
6754   TYPE_HAS_CONST_INIT_REF (t) = 0;
6755   TYPE_HAS_ASSIGN_REF (t) = 0;
6756   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6757
6758   /* Splice the implicitly generated functions out of the TYPE_METHODS
6759      list.  */
6760   q = &TYPE_METHODS (t);
6761   while (*q)
6762     {
6763       if (DECL_ARTIFICIAL (*q))
6764         *q = TREE_CHAIN (*q);
6765       else
6766         q = &TREE_CHAIN (*q);
6767     }
6768
6769   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6770   if (TYPE_METHODS (t))
6771     error ("an anonymous union cannot have function members");
6772 }
6773
6774 /* Make sure that a declaration with no declarator is well-formed, i.e.
6775    just defines a tagged type or anonymous union.
6776
6777    Returns the type defined, if any.  */
6778
6779 tree
6780 check_tag_decl (declspecs)
6781      tree declspecs;
6782 {
6783   int found_type = 0;
6784   int saw_friend = 0;
6785   tree ob_modifier = NULL_TREE;
6786   register tree link;
6787   register tree t = NULL_TREE;
6788
6789   for (link = declspecs; link; link = TREE_CHAIN (link))
6790     {
6791       register tree value = TREE_VALUE (link);
6792
6793       if (TYPE_P (value)
6794           || (TREE_CODE (value) == IDENTIFIER_NODE
6795               && IDENTIFIER_GLOBAL_VALUE (value)
6796               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6797         {
6798           ++found_type;
6799
6800           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6801             {
6802               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6803               t = value;
6804             }
6805         }
6806       else if (value == ridpointers[(int) RID_FRIEND])
6807         {
6808           if (current_class_type == NULL_TREE
6809               || current_scope () != current_class_type)
6810             ob_modifier = value;
6811           else
6812             saw_friend = 1;
6813         }
6814       else if (value == ridpointers[(int) RID_STATIC]
6815                || value == ridpointers[(int) RID_EXTERN]
6816                || value == ridpointers[(int) RID_AUTO]
6817                || value == ridpointers[(int) RID_REGISTER]
6818                || value == ridpointers[(int) RID_INLINE]
6819                || value == ridpointers[(int) RID_VIRTUAL]
6820                || value == ridpointers[(int) RID_CONST]
6821                || value == ridpointers[(int) RID_VOLATILE]
6822                || value == ridpointers[(int) RID_EXPLICIT])
6823         ob_modifier = value;
6824     }
6825
6826   if (found_type > 1)
6827     error ("multiple types in one declaration");
6828
6829   if (t == NULL_TREE && ! saw_friend)
6830     pedwarn ("declaration does not declare anything");
6831
6832   /* Check for an anonymous union.  We're careful
6833      accessing TYPE_IDENTIFIER because some built-in types, like
6834      pointer-to-member types, do not have TYPE_NAME.  */
6835   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6836            && TYPE_NAME (t)
6837            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6838     {
6839       /* Anonymous unions are objects, so they can have specifiers.  */;
6840       SET_ANON_AGGR_TYPE_P (t);
6841
6842       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6843         pedwarn ("ISO C++ prohibits anonymous structs");
6844     }
6845
6846   else if (ob_modifier)
6847     {
6848       if (ob_modifier == ridpointers[(int) RID_INLINE]
6849           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6850         cp_error ("`%D' can only be specified for functions", ob_modifier);
6851       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6852         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6853       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6854         cp_error ("`%D' can only be specified for constructors",
6855                   ob_modifier);
6856       else
6857         cp_error ("`%D' can only be specified for objects and functions",
6858                   ob_modifier);
6859     }
6860
6861   return t;
6862 }
6863
6864 /* Called when a declaration is seen that contains no names to declare.
6865    If its type is a reference to a structure, union or enum inherited
6866    from a containing scope, shadow that tag name for the current scope
6867    with a forward reference.
6868    If its type defines a new named structure or union
6869    or defines an enum, it is valid but we need not do anything here.
6870    Otherwise, it is an error.
6871
6872    C++: may have to grok the declspecs to learn about static,
6873    complain for anonymous unions.  */
6874
6875 void
6876 shadow_tag (declspecs)
6877      tree declspecs;
6878 {
6879   tree t = check_tag_decl (declspecs);
6880
6881   if (t)
6882     maybe_process_partial_specialization (t);
6883
6884   /* This is where the variables in an anonymous union are
6885      declared.  An anonymous union declaration looks like:
6886      union { ... } ;
6887      because there is no declarator after the union, the parser
6888      sends that declaration here.  */
6889   if (t && ANON_AGGR_TYPE_P (t))
6890     {
6891       fixup_anonymous_aggr (t);
6892
6893       if (TYPE_FIELDS (t))
6894         {
6895           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6896                                       NULL_TREE);
6897           finish_anon_union (decl);
6898         }
6899     }
6900 }
6901 \f
6902 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6903
6904 tree
6905 groktypename (typename)
6906      tree typename;
6907 {
6908   if (TREE_CODE (typename) != TREE_LIST)
6909     return typename;
6910   return grokdeclarator (TREE_VALUE (typename),
6911                          TREE_PURPOSE (typename),
6912                          TYPENAME, 0, NULL_TREE);
6913 }
6914
6915 /* Decode a declarator in an ordinary declaration or data definition.
6916    This is called as soon as the type information and variable name
6917    have been parsed, before parsing the initializer if any.
6918    Here we create the ..._DECL node, fill in its type,
6919    and put it on the list of decls for the current context.
6920    The ..._DECL node is returned as the value.
6921
6922    Exception: for arrays where the length is not specified,
6923    the type is left null, to be filled in by `cp_finish_decl'.
6924
6925    Function definitions do not come here; they go to start_function
6926    instead.  However, external and forward declarations of functions
6927    do go through here.  Structure field declarations are done by
6928    grokfield and not through here.  */
6929
6930 tree
6931 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6932      tree declarator, declspecs;
6933      int initialized;
6934      tree attributes, prefix_attributes;
6935 {
6936   register tree decl;
6937   register tree type, tem;
6938   tree context;
6939   extern int have_extern_spec;
6940   extern int used_extern_spec;
6941   tree attrlist;
6942
6943 #if 0
6944   /* See code below that used this.  */
6945   int init_written = initialized;
6946 #endif
6947
6948   /* This should only be done once on the top most decl.  */
6949   if (have_extern_spec && !used_extern_spec)
6950     {
6951       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6952                                   declspecs);
6953       used_extern_spec = 1;
6954     }
6955
6956   if (attributes || prefix_attributes)
6957     attrlist = build_tree_list (attributes, prefix_attributes);
6958   else
6959     attrlist = NULL_TREE;
6960
6961   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6962                          attrlist);
6963
6964   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6965     return NULL_TREE;
6966
6967   type = TREE_TYPE (decl);
6968
6969   if (type == error_mark_node)
6970     return NULL_TREE;
6971
6972   context = DECL_CONTEXT (decl);
6973
6974   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
6975       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
6976     {
6977       /* When parsing the initializer, lookup should use the object's
6978          namespace. */
6979       push_decl_namespace (context);
6980     }
6981
6982   /* We are only interested in class contexts, later. */
6983   if (context && TREE_CODE (context) == NAMESPACE_DECL)
6984     context = NULL_TREE;
6985
6986   if (initialized)
6987     /* Is it valid for this decl to have an initializer at all?
6988        If not, set INITIALIZED to zero, which will indirectly
6989        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6990     switch (TREE_CODE (decl))
6991       {
6992       case TYPE_DECL:
6993         /* typedef foo = bar  means give foo the same type as bar.
6994            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6995            Any other case of an initialization in a TYPE_DECL is an error.  */
6996         if (pedantic || list_length (declspecs) > 1)
6997           {
6998             cp_error ("typedef `%D' is initialized", decl);
6999             initialized = 0;
7000           }
7001         break;
7002
7003       case FUNCTION_DECL:
7004         cp_error ("function `%#D' is initialized like a variable", decl);
7005         initialized = 0;
7006         break;
7007
7008       default:
7009         break;
7010       }
7011
7012   if (initialized)
7013     {
7014       if (! toplevel_bindings_p ()
7015           && DECL_EXTERNAL (decl))
7016         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7017                     decl);
7018       DECL_EXTERNAL (decl) = 0;
7019       if (toplevel_bindings_p ())
7020         TREE_STATIC (decl) = 1;
7021
7022       /* Tell `pushdecl' this is an initialized decl
7023          even though we don't yet have the initializer expression.
7024          Also tell `cp_finish_decl' it may store the real initializer.  */
7025       DECL_INITIAL (decl) = error_mark_node;
7026     }
7027
7028 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7029   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7030 #endif
7031
7032   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7033   cplus_decl_attributes (decl, attributes, prefix_attributes);
7034
7035   if (context && COMPLETE_TYPE_P (complete_type (context)))
7036     {
7037       push_nested_class (context, 2);
7038
7039       if (TREE_CODE (decl) == VAR_DECL)
7040         {
7041           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7042           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7043             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7044           else
7045             {
7046               if (DECL_CONTEXT (field) != context)
7047                 {
7048                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7049                               DECL_CONTEXT (field), DECL_NAME (decl),
7050                               context, DECL_NAME (decl));
7051                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7052                 }
7053               /* Static data member are tricky; an in-class initialization
7054                  still doesn't provide a definition, so the in-class
7055                  declaration will have DECL_EXTERNAL set, but will have an
7056                  initialization.  Thus, duplicate_decls won't warn
7057                  about this situation, and so we check here.  */
7058               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7059                 cp_error ("duplicate initialization of %D", decl);
7060               if (duplicate_decls (decl, field))
7061                 decl = field;
7062             }
7063         }
7064       else
7065         {
7066           tree field = check_classfn (context, decl);
7067           if (field && duplicate_decls (decl, field))
7068             decl = field;
7069         }
7070
7071       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7072       DECL_IN_AGGR_P (decl) = 0;
7073       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7074           || CLASSTYPE_USE_TEMPLATE (context))
7075         {
7076           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7077           /* [temp.expl.spec] An explicit specialization of a static data
7078              member of a template is a definition if the declaration
7079              includes an initializer; otherwise, it is a declaration.
7080
7081              We check for processing_specialization so this only applies
7082              to the new specialization syntax.  */
7083           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7084             DECL_EXTERNAL (decl) = 1;
7085         }
7086
7087       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7088         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7089                     decl);
7090     }
7091
7092   /* Enter this declaration into the symbol table.  */
7093   tem = maybe_push_decl (decl);
7094
7095   if (processing_template_decl)
7096     tem = push_template_decl (tem);
7097
7098 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7099   /* Tell the back-end to use or not use .common as appropriate.  If we say
7100      -fconserve-space, we want this to save .data space, at the expense of
7101      wrong semantics.  If we say -fno-conserve-space, we want this to
7102      produce errors about redefs; to do this we force variables into the
7103      data segment.  */
7104   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7105 #endif
7106
7107   if (! processing_template_decl)
7108     start_decl_1 (tem);
7109
7110   return tem;
7111 }
7112
7113 void
7114 start_decl_1 (decl)
7115      tree decl;
7116 {
7117   tree type = TREE_TYPE (decl);
7118   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7119
7120   if (type == error_mark_node)
7121     return;
7122
7123   /* If this type of object needs a cleanup, but we're not allowed to
7124      add any more objects with cleanups to the current scope, create a
7125      new binding level.  */
7126   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7127       && current_binding_level->more_cleanups_ok == 0)
7128     {
7129       keep_next_level (2);
7130       pushlevel (1);
7131       clear_last_expr ();
7132       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7133     }
7134
7135   if (initialized)
7136     /* Is it valid for this decl to have an initializer at all?
7137        If not, set INITIALIZED to zero, which will indirectly
7138        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7139     {
7140       /* Don't allow initializations for incomplete types except for
7141          arrays which might be completed by the initialization.  */
7142       if (COMPLETE_TYPE_P (complete_type (type)))
7143         ;                       /* A complete type is ok.  */
7144       else if (TREE_CODE (type) != ARRAY_TYPE)
7145         {
7146           cp_error ("variable `%#D' has initializer but incomplete type",
7147                     decl);
7148           initialized = 0;
7149           type = TREE_TYPE (decl) = error_mark_node;
7150         }
7151       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7152         {
7153           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7154             cp_error ("elements of array `%#D' have incomplete type", decl);
7155           /* else we already gave an error in start_decl.  */
7156           initialized = 0;
7157         }
7158     }
7159
7160   if (!initialized
7161       && TREE_CODE (decl) != TYPE_DECL
7162       && TREE_CODE (decl) != TEMPLATE_DECL
7163       && type != error_mark_node
7164       && IS_AGGR_TYPE (type)
7165       && ! DECL_EXTERNAL (decl))
7166     {
7167       if ((! processing_template_decl || ! uses_template_parms (type))
7168           && !COMPLETE_TYPE_P (complete_type (type)))
7169         {
7170           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7171                  decl);
7172           /* Change the type so that assemble_variable will give
7173              DECL an rtl we can live with: (mem (const_int 0)).  */
7174           type = TREE_TYPE (decl) = error_mark_node;
7175         }
7176       else
7177         {
7178           /* If any base type in the hierarchy of TYPE needs a constructor,
7179              then we set initialized to 1.  This way any nodes which are
7180              created for the purposes of initializing this aggregate
7181              will live as long as it does.  This is necessary for global
7182              aggregates which do not have their initializers processed until
7183              the end of the file.  */
7184           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7185         }
7186     }
7187
7188   if (! initialized)
7189     DECL_INITIAL (decl) = NULL_TREE;
7190 }
7191
7192 /* Handle initialization of references.
7193    These three arguments are from `cp_finish_decl', and have the
7194    same meaning here that they do there.
7195
7196    Quotes on semantics can be found in ARM 8.4.3.  */
7197
7198 static void
7199 grok_reference_init (decl, type, init)
7200      tree decl, type, init;
7201 {
7202   tree tmp;
7203
7204   if (init == NULL_TREE)
7205     {
7206       if ((DECL_LANG_SPECIFIC (decl) == 0
7207            || DECL_IN_AGGR_P (decl) == 0)
7208           && ! DECL_THIS_EXTERN (decl))
7209         cp_error ("`%D' declared as reference but not initialized", decl);
7210       return;
7211     }
7212
7213   if (init == error_mark_node)
7214     return;
7215
7216   if (TREE_CODE (init) == CONSTRUCTOR)
7217     {
7218       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7219       return;
7220     }
7221
7222   if (TREE_CODE (init) == TREE_LIST)
7223     init = build_compound_expr (init);
7224
7225   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7226     init = convert_from_reference (init);
7227
7228   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7229       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7230     {
7231       /* Note: default conversion is only called in very special cases.  */
7232       init = default_conversion (init);
7233     }
7234
7235   /* Convert INIT to the reference type TYPE.  This may involve the
7236      creation of a temporary, whose lifetime must be the same as that
7237      of the reference.  If so, a DECL_STMT for the temporary will be
7238      added just after the DECL_STMT for DECL.  That's why we don't set
7239      DECL_INITIAL for local references (instead assigning to them
7240      explicitly); we need to allow the temporary to be initialized
7241      first.  */
7242   tmp = convert_to_reference
7243     (type, init, CONV_IMPLICIT,
7244      LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
7245
7246   if (tmp == error_mark_node)
7247     return;
7248   else if (tmp != NULL_TREE)
7249     {
7250       init = tmp;
7251       tmp = save_expr (tmp);
7252       if (building_stmt_tree ())
7253         {
7254           /* Initialize the declaration.  */
7255           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7256           finish_expr_stmt (tmp);
7257         }
7258       else
7259         DECL_INITIAL (decl) = tmp;
7260     }
7261   else
7262     {
7263       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7264       return;
7265     }
7266
7267   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7268     {
7269       expand_static_init (decl, DECL_INITIAL (decl));
7270       DECL_INITIAL (decl) = NULL_TREE;
7271     }
7272   return;
7273 }
7274
7275 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7276    mucking with forces it does not comprehend (i.e. initialization with a
7277    constructor).  If we are at global scope and won't go into COMMON, fill
7278    it in with a dummy CONSTRUCTOR to force the variable into .data;
7279    otherwise we can use error_mark_node.  */
7280
7281 static tree
7282 obscure_complex_init (decl, init)
7283      tree decl, init;
7284 {
7285   if (! flag_no_inline && TREE_STATIC (decl))
7286     {
7287       if (extract_init (decl, init))
7288         return NULL_TREE;
7289     }
7290
7291 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7292   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7293     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7294                                  NULL_TREE);
7295   else
7296 #endif
7297     DECL_INITIAL (decl) = error_mark_node;
7298
7299   return init;
7300 }
7301
7302 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7303    array until we finish parsing the initializer.  If that's the
7304    situation we're in, update DECL accordingly.  */
7305
7306 static void
7307 maybe_deduce_size_from_array_init (decl, init)
7308      tree decl;
7309      tree init;
7310 {
7311   tree type = TREE_TYPE (decl);
7312
7313   if (TREE_CODE (type) == ARRAY_TYPE
7314       && TYPE_DOMAIN (type) == NULL_TREE
7315       && TREE_CODE (decl) != TYPE_DECL)
7316     {
7317       int do_default
7318         = (TREE_STATIC (decl)
7319            /* Even if pedantic, an external linkage array
7320               may have incomplete type at first.  */
7321            ? pedantic && ! DECL_EXTERNAL (decl)
7322            : !DECL_EXTERNAL (decl));
7323       tree initializer = init ? init : DECL_INITIAL (decl);
7324       int failure = complete_array_type (type, initializer, do_default);
7325
7326       if (failure == 1)
7327         cp_error ("initializer fails to determine size of `%D'", decl);
7328
7329       if (failure == 2)
7330         {
7331           if (do_default)
7332             cp_error ("array size missing in `%D'", decl);
7333           /* If a `static' var's size isn't known, make it extern as
7334              well as static, so it does not get allocated.  If it's not
7335              `static', then don't mark it extern; finish_incomplete_decl
7336              will give it a default size and it will get allocated.  */
7337           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7338             DECL_EXTERNAL (decl) = 1;
7339         }
7340
7341       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7342           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7343                               integer_zero_node))
7344         cp_error ("zero-size array `%D'", decl);
7345
7346       layout_decl (decl, 0);
7347     }
7348 }
7349
7350 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7351    any appropriate error messages regarding the layout.  */
7352
7353 static void
7354 layout_var_decl (decl)
7355      tree decl;
7356 {
7357   tree type = TREE_TYPE (decl);
7358 #if 0
7359   tree ttype = target_type (type);
7360 #endif
7361
7362   /* If we haven't already layed out this declaration, do so now.
7363      Note that we must not call complete type for an external object
7364      because it's type might involve templates that we are not
7365      supposed to isntantiate yet.  (And it's perfectly legal to say
7366      `extern X x' for some incomplete type `X'.)  */
7367   if (!DECL_EXTERNAL (decl))
7368     complete_type (type);
7369   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7370     layout_decl (decl, 0);
7371
7372   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7373     {
7374       /* An automatic variable with an incomplete type: that is an error.
7375          Don't talk about array types here, since we took care of that
7376          message in grokdeclarator.  */
7377       cp_error ("storage size of `%D' isn't known", decl);
7378       TREE_TYPE (decl) = error_mark_node;
7379     }
7380 #if 0
7381   /* Keep this code around in case we later want to control debug info
7382      based on whether a type is "used".  (jason 1999-11-11) */
7383
7384   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7385     /* Let debugger know it should output info for this type.  */
7386     note_debug_info_needed (ttype);
7387
7388   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7389     note_debug_info_needed (DECL_CONTEXT (decl));
7390 #endif
7391
7392   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7393       && DECL_SIZE (decl) != NULL_TREE
7394       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7395     {
7396       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7397         constant_expression_warning (DECL_SIZE (decl));
7398       else
7399         cp_error ("storage size of `%D' isn't constant", decl);
7400     }
7401 }
7402
7403 /* If a local static variable is declared in an inline function, or if
7404    we have a weak definition, we must endeavor to create only one
7405    instance of the variable at link-time.  */
7406
7407 static void
7408 maybe_commonize_var (decl)
7409      tree decl;
7410 {
7411   /* Static data in a function with comdat linkage also has comdat
7412      linkage.  */
7413   if (TREE_STATIC (decl)
7414       /* Don't mess with __FUNCTION__.  */
7415       && ! DECL_ARTIFICIAL (decl)
7416       && current_function_decl
7417       && DECL_CONTEXT (decl) == current_function_decl
7418       && (DECL_THIS_INLINE (current_function_decl)
7419           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7420       && TREE_PUBLIC (current_function_decl))
7421     {
7422       /* Rather than try to get this right with inlining, we suppress
7423          inlining of such functions.  */
7424       current_function_cannot_inline
7425         = "function with static variable cannot be inline";
7426
7427       /* If flag_weak, we don't need to mess with this, as we can just
7428          make the function weak, and let it refer to its unique local
7429          copy.  This works because we don't allow the function to be
7430          inlined.  */
7431       if (! flag_weak)
7432         {
7433           if (DECL_INTERFACE_KNOWN (current_function_decl))
7434             {
7435               TREE_PUBLIC (decl) = 1;
7436               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7437             }
7438           else if (DECL_INITIAL (decl) == NULL_TREE
7439                    || DECL_INITIAL (decl) == error_mark_node)
7440             {
7441               TREE_PUBLIC (decl) = 1;
7442               DECL_COMMON (decl) = 1;
7443             }
7444           /* else we lose. We can only do this if we can use common,
7445              which we can't if it has been initialized.  */
7446
7447           if (TREE_PUBLIC (decl))
7448             DECL_ASSEMBLER_NAME (decl)
7449               = build_static_name (current_function_decl, DECL_NAME (decl));
7450           else
7451             {
7452               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7453               cp_warning_at ("  you can work around this by removing the initializer", decl);
7454             }
7455         }
7456     }
7457   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7458     /* Set it up again; we might have set DECL_INITIAL since the last
7459        time.  */
7460     comdat_linkage (decl);
7461 }
7462
7463 /* Issue an error message if DECL is an uninitialized const variable.  */
7464
7465 static void
7466 check_for_uninitialized_const_var (decl)
7467      tree decl;
7468 {
7469   tree type = TREE_TYPE (decl);
7470
7471   /* ``Unless explicitly declared extern, a const object does not have
7472      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7473      7.1.6 */
7474   if (TREE_CODE (decl) == VAR_DECL
7475       && TREE_CODE (type) != REFERENCE_TYPE
7476       && CP_TYPE_CONST_P (type)
7477       && !TYPE_NEEDS_CONSTRUCTING (type)
7478       && !DECL_INITIAL (decl))
7479     cp_error ("uninitialized const `%D'", decl);
7480 }
7481
7482 /* Verify INIT (the initializer for DECL), and record the
7483    initialization in DECL_INITIAL, if appropriate.  Returns a new
7484    value for INIT.  */
7485
7486 static tree
7487 check_initializer (decl, init)
7488      tree decl;
7489      tree init;
7490 {
7491   tree type;
7492
7493   if (TREE_CODE (decl) == FIELD_DECL)
7494     return init;
7495
7496   type = TREE_TYPE (decl);
7497
7498   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7499   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7500     init = NULL_TREE;
7501
7502   /* Check the initializer.  */
7503   if (init)
7504     {
7505       /* Things that are going to be initialized need to have complete
7506          type.  */
7507       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7508
7509       if (type == error_mark_node)
7510         /* We will have already complained.  */
7511         init = NULL_TREE;
7512       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7513         {
7514           cp_error ("variable-sized object `%D' may not be initialized", decl);
7515           init = NULL_TREE;
7516         }
7517       else if (TREE_CODE (type) == ARRAY_TYPE
7518                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7519         {
7520           cp_error ("elements of array `%#D' have incomplete type", decl);
7521           init = NULL_TREE;
7522         }
7523       else if (!COMPLETE_TYPE_P (type))
7524         {
7525           cp_error ("`%D' has incomplete type", decl);
7526           TREE_TYPE (decl) = error_mark_node;
7527           init = NULL_TREE;
7528         }
7529     }
7530
7531   if (TREE_CODE (decl) == CONST_DECL)
7532     {
7533       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7534
7535       DECL_INITIAL (decl) = init;
7536
7537       /* This will keep us from needing to worry about our obstacks.  */
7538       my_friendly_assert (init != NULL_TREE, 149);
7539       init = NULL_TREE;
7540     }
7541   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7542     {
7543       if (TREE_STATIC (decl))
7544         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7545       grok_reference_init (decl, type, init);
7546       init = NULL_TREE;
7547     }
7548   else if (init)
7549     {
7550       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7551         {
7552           if (TREE_CODE (type) == ARRAY_TYPE)
7553             init = digest_init (type, init, (tree *) 0);
7554           else if (TREE_CODE (init) == CONSTRUCTOR
7555                    && TREE_HAS_CONSTRUCTOR (init))
7556             {
7557               if (TYPE_NON_AGGREGATE_CLASS (type))
7558                 {
7559                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7560                             decl);
7561                   init = error_mark_node;
7562                 }
7563               else
7564                 goto dont_use_constructor;
7565             }
7566         }
7567       else
7568         {
7569         dont_use_constructor:
7570           if (TREE_CODE (init) != TREE_VEC)
7571             init = store_init_value (decl, init);
7572         }
7573
7574       if (init)
7575         /* We must hide the initializer so that expand_decl
7576            won't try to do something it does not understand.  */
7577         init = obscure_complex_init (decl, init);
7578     }
7579   else if (DECL_EXTERNAL (decl))
7580     ;
7581   else if (TYPE_P (type)
7582            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7583     {
7584       tree core_type = strip_array_types (type);
7585
7586       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7587         {
7588           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7589             cp_error ("structure `%D' with uninitialized const members", decl);
7590           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7591             cp_error ("structure `%D' with uninitialized reference members",
7592                       decl);
7593         }
7594
7595       check_for_uninitialized_const_var (decl);
7596
7597       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7598         init = obscure_complex_init (decl, NULL_TREE);
7599
7600     }
7601   else
7602     check_for_uninitialized_const_var (decl);
7603
7604   return init;
7605 }
7606
7607 /* If DECL is not a local variable, give it RTL.  */
7608
7609 static void
7610 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7611      tree decl;
7612      tree init;
7613      const char *asmspec;
7614 {
7615   int toplev;
7616   tree type;
7617
7618   type = TREE_TYPE (decl);
7619   toplev = toplevel_bindings_p ();
7620
7621   /* Handle non-variables up front.  */
7622   if (TREE_CODE (decl) != VAR_DECL)
7623     {
7624       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7625       return;
7626     }
7627
7628   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7629   if (asmspec)
7630     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7631
7632   if (DECL_VIRTUAL_P (decl))
7633     make_decl_rtl (decl, NULL_PTR, toplev);
7634   else if (TREE_READONLY (decl)
7635            && DECL_INITIAL (decl) != NULL_TREE
7636            && DECL_INITIAL (decl) != error_mark_node
7637            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7638     {
7639       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7640
7641       if (toplev && ! TREE_PUBLIC (decl))
7642         {
7643           /* If this is a static const, change its apparent linkage
7644              if it belongs to a #pragma interface.  */
7645           if (!interface_unknown)
7646             {
7647               TREE_PUBLIC (decl) = 1;
7648               DECL_EXTERNAL (decl) = interface_only;
7649             }
7650           make_decl_rtl (decl, asmspec, toplev);
7651         }
7652       else if (toplev)
7653         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7654     }
7655   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7656     {
7657       my_friendly_assert (TREE_STATIC (decl), 19990828);
7658
7659       if (init == NULL_TREE
7660 #ifdef DEFAULT_STATIC_DEFS
7661           /* If this code is dead, then users must
7662              explicitly declare static member variables
7663              outside the class def'n as well.  */
7664           && TYPE_NEEDS_CONSTRUCTING (type)
7665 #endif
7666           )
7667         {
7668           DECL_EXTERNAL (decl) = 1;
7669           make_decl_rtl (decl, asmspec, 1);
7670         }
7671       else
7672         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7673     }
7674   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7675            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7676     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7677 }
7678
7679 /* Create RTL for the local static variable DECL.  */
7680
7681 void
7682 make_rtl_for_local_static (decl)
7683      tree decl;
7684 {
7685   const char *asmspec = NULL;
7686
7687   /* If we inlined this variable, we could see it's declaration
7688      again.  */
7689   if (DECL_RTL (decl))
7690     return;
7691
7692   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7693     {
7694       /* The only way this situaton can occur is if the
7695          user specified a name for this DECL using the
7696          `attribute' syntax.  */
7697       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7698       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7699     }
7700
7701   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7702 }
7703
7704 /* The old ARM scoping rules injected variables declared in the
7705    initialization statement of a for-statement into the surrounding
7706    scope.  We support this usage, in order to be backward-compatible.
7707    DECL is a just-declared VAR_DECL; if necessary inject its
7708    declaration into the surrounding scope.  */
7709
7710 void
7711 maybe_inject_for_scope_var (decl)
7712      tree decl;
7713 {
7714   if (current_binding_level->is_for_scope)
7715     {
7716       struct binding_level *outer
7717         = current_binding_level->level_chain;
7718
7719       /* Check to see if the same name is already bound at the outer
7720          level, either because it was directly declared, or because a
7721          dead for-decl got preserved.  In either case, the code would
7722          not have been valid under the ARM scope rules, so clear
7723          is_for_scope for the current_binding_level.
7724
7725          Otherwise, we need to preserve the temp slot for decl to last
7726          into the outer binding level.  */
7727
7728       tree outer_binding
7729         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7730
7731       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7732           && (TREE_CODE (BINDING_VALUE (outer_binding))
7733               == VAR_DECL)
7734           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7735         {
7736           BINDING_VALUE (outer_binding)
7737             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7738           current_binding_level->is_for_scope = 0;
7739         }
7740       else if (DECL_IN_MEMORY_P (decl))
7741         preserve_temp_slots (DECL_RTL (decl));
7742     }
7743 }
7744
7745 /* Generate code to initialize DECL (a local variable).  */
7746
7747 void
7748 initialize_local_var (decl, init, flags)
7749      tree decl;
7750      tree init;
7751      int flags;
7752 {
7753   tree type = TREE_TYPE (decl);
7754
7755   /* If the type is bogus, don't bother initializing the variable.  */
7756   if (type == error_mark_node)
7757     return;
7758
7759   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7760     {
7761       /* If we used it already as memory, it must stay in memory.  */
7762       DECL_INITIAL (decl) = NULL_TREE;
7763       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7764     }
7765
7766   /* Local statics are handled differently from ordinary automatic
7767      variables.  */
7768   if (TREE_STATIC (decl))
7769     {
7770       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7771           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7772         expand_static_init (decl, init);
7773       return;
7774     }
7775
7776   if (DECL_SIZE (decl) && type != error_mark_node)
7777     {
7778       int already_used;
7779
7780       /* Compute and store the initial value.  */
7781       already_used = TREE_USED (decl) || TREE_USED (type);
7782
7783       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7784         {
7785           int saved_stmts_are_full_exprs_p;
7786
7787           emit_line_note (DECL_SOURCE_FILE (decl),
7788                           DECL_SOURCE_LINE (decl));
7789           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7790           stmts_are_full_exprs_p = 1;
7791           finish_expr_stmt (build_aggr_init (decl, init, flags));
7792           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7793         }
7794
7795       /* Set this to 0 so we can tell whether an aggregate which was
7796          initialized was ever used.  Don't do this if it has a
7797          destructor, so we don't complain about the 'resource
7798          allocation is initialization' idiom.  Now set
7799          attribute((unused)) on types so decls of that type will be
7800          marked used. (see TREE_USED, above.)  */
7801       if (TYPE_NEEDS_CONSTRUCTING (type)
7802           && ! already_used
7803           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7804           && DECL_NAME (decl))
7805         TREE_USED (decl) = 0;
7806       else if (already_used)
7807         TREE_USED (decl) = 1;
7808     }
7809 }
7810
7811 /* Generate code to destroy DECL (a local variable).  */
7812
7813 static void
7814 destroy_local_var (decl)
7815      tree decl;
7816 {
7817   tree type = TREE_TYPE (decl);
7818   tree cleanup;
7819
7820   /* Only variables get cleaned up.  */
7821   if (TREE_CODE (decl) != VAR_DECL)
7822     return;
7823
7824   /* And only things with destructors need cleaning up.  */
7825   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7826     return;
7827
7828   if (TREE_CODE (decl) == VAR_DECL &&
7829       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7830     /* We don't clean up things that aren't defined in this
7831        translation unit, or that need a static cleanup.  The latter
7832        are handled by finish_file.  */
7833     return;
7834
7835   /* Compute the cleanup.  */
7836   cleanup = maybe_build_cleanup (decl);
7837
7838   /* Record the cleanup required for this declaration.  */
7839   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7840       && cleanup)
7841     finish_decl_cleanup (decl, cleanup);
7842 }
7843
7844 /* Let the back-end know about DECL.  */
7845
7846 void
7847 emit_local_var (decl)
7848      tree decl;
7849 {
7850   /* Create RTL for this variable.  */
7851   if (DECL_RTL (decl))
7852     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7853        All other local variables are assigned RTL in this function.  */
7854     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
7855                         19990828);
7856   else
7857     {
7858       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7859         /* The user must have specified an assembler name for this
7860            variable.  Set that up now.  */
7861         rest_of_decl_compilation
7862           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
7863            /*top_level=*/0, /*at_end=*/0);
7864       else
7865         expand_decl (decl);
7866     }
7867
7868   /* Actually do the initialization.  */
7869   expand_start_target_temps ();
7870   expand_decl_init (decl);
7871   expand_end_target_temps ();
7872 }
7873
7874 /* Finish processing of a declaration;
7875    install its line number and initial value.
7876    If the length of an array type is not known before,
7877    it must be determined now, from the initial value, or it is an error.
7878
7879    INIT0 holds the value of an initializer that should be allowed to escape
7880    the normal rules.
7881
7882    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7883    if the (init) syntax was used.  */
7884
7885 void
7886 cp_finish_decl (decl, init, asmspec_tree, flags)
7887      tree decl, init;
7888      tree asmspec_tree;
7889      int flags;
7890 {
7891   register tree type;
7892   tree ttype = NULL_TREE;
7893   const char *asmspec = NULL;
7894   int was_readonly = 0;
7895
7896   if (! decl)
7897     {
7898       if (init)
7899         error ("assignment (not initialization) in declaration");
7900       return;
7901     }
7902
7903   /* If a name was specified, get the string.  */
7904   if (asmspec_tree)
7905       asmspec = TREE_STRING_POINTER (asmspec_tree);
7906
7907   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7908     {
7909       cp_error ("cannot initialize `%D' to namespace `%D'",
7910                 decl, init);
7911       init = NULL_TREE;
7912     }
7913
7914   if (current_class_type
7915       && CP_DECL_CONTEXT (decl) == current_class_type
7916       && TYPE_BEING_DEFINED (current_class_type)
7917       && (DECL_INITIAL (decl) || init))
7918     DECL_DEFINED_IN_CLASS_P (decl) = 1;
7919
7920   if (TREE_CODE (decl) == VAR_DECL
7921       && DECL_CONTEXT (decl)
7922       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7923       && DECL_CONTEXT (decl) != current_namespace
7924       && init)
7925     {
7926       /* Leave the namespace of the object. */
7927       pop_decl_namespace ();
7928     }
7929
7930   type = TREE_TYPE (decl);
7931
7932   if (type == error_mark_node)
7933     return;
7934
7935   /* Add this declaration to the statement-tree.  */
7936   if (building_stmt_tree () && at_function_scope_p ())
7937     add_decl_stmt (decl);
7938
7939   if (TYPE_HAS_MUTABLE_P (type))
7940     TREE_READONLY (decl) = 0;
7941
7942   if (processing_template_decl)
7943     {
7944       if (init && DECL_INITIAL (decl))
7945         DECL_INITIAL (decl) = init;
7946       goto finish_end0;
7947     }
7948
7949   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7950   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7951
7952   /* Take care of TYPE_DECLs up front.  */
7953   if (TREE_CODE (decl) == TYPE_DECL)
7954     {
7955       if (init && DECL_INITIAL (decl))
7956         {
7957           /* typedef foo = bar; store the type of bar as the type of foo.  */
7958           TREE_TYPE (decl) = type = TREE_TYPE (init);
7959           DECL_INITIAL (decl) = init = NULL_TREE;
7960         }
7961       if (type != error_mark_node
7962           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7963         {
7964           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7965             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7966           set_identifier_type_value (DECL_NAME (decl), type);
7967           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7968         }
7969       GNU_xref_decl (current_function_decl, decl);
7970
7971       /* If we have installed this as the canonical typedef for this
7972          type, and that type has not been defined yet, delay emitting
7973          the debug information for it, as we will emit it later.  */
7974       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7975           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
7976         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7977
7978       rest_of_decl_compilation (decl, NULL_PTR,
7979                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7980       goto finish_end;
7981     }
7982
7983   if (TREE_CODE (decl) != FUNCTION_DECL)
7984     ttype = target_type (type);
7985
7986   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7987       && TYPE_NEEDS_CONSTRUCTING (type))
7988     {
7989       /* Currently, GNU C++ puts constants in text space, making them
7990          impossible to initialize.  In the future, one would hope for
7991          an operating system which understood the difference between
7992          initialization and the running of a program.  */
7993       was_readonly = 1;
7994       TREE_READONLY (decl) = 0;
7995     }
7996
7997   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
7998     {
7999       /* This must override the asm specifier which was placed by
8000          grokclassfn.  Lay this out fresh.  */
8001       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8002       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8003       make_decl_rtl (decl, asmspec, 0);
8004     }
8005
8006   /* Deduce size of array from initialization, if not already known.  */
8007   maybe_deduce_size_from_array_init (decl, init);
8008   init = check_initializer (decl, init);
8009
8010   GNU_xref_decl (current_function_decl, decl);
8011
8012   if (TREE_CODE (decl) == VAR_DECL)
8013     layout_var_decl (decl);
8014
8015   /* Output the assembler code and/or RTL code for variables and functions,
8016      unless the type is an undefined structure or union.
8017      If not, it will get done when the type is completed.  */
8018   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8019       || TREE_CODE (decl) == RESULT_DECL)
8020     {
8021       if (TREE_CODE (decl) == VAR_DECL)
8022         maybe_commonize_var (decl);
8023
8024       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8025
8026       if (TREE_CODE (type) == FUNCTION_TYPE
8027           || TREE_CODE (type) == METHOD_TYPE)
8028         abstract_virtuals_error (decl,
8029                                  strip_array_types (TREE_TYPE (type)));
8030       else
8031         abstract_virtuals_error (decl, strip_array_types (type));
8032
8033       if (TREE_CODE (decl) == FUNCTION_DECL)
8034         ;
8035       else if (DECL_EXTERNAL (decl)
8036                && ! (DECL_LANG_SPECIFIC (decl)
8037                      && DECL_NOT_REALLY_EXTERN (decl)))
8038         {
8039           if (init)
8040             DECL_INITIAL (decl) = init;
8041         }
8042       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8043         {
8044           /* This is a local declaration.  */
8045           if (doing_semantic_analysis_p ())
8046             maybe_inject_for_scope_var (decl);
8047           /* Initialize the local variable.  But, if we're building a
8048              statement-tree, we'll do the initialization when we
8049              expand the tree.  */
8050           if (processing_template_decl)
8051             {
8052               if (init || DECL_INITIAL (decl) == error_mark_node)
8053                 DECL_INITIAL (decl) = init;
8054             }
8055           else
8056             {
8057               /* If we're not building RTL, then we need to do so
8058                  now.  */
8059               if (!building_stmt_tree ())
8060                 emit_local_var (decl);
8061               /* Initialize the variable.  */
8062               initialize_local_var (decl, init, flags);
8063               /* Clean up the variable.  */
8064               destroy_local_var (decl);
8065             }
8066         }
8067       else if (TREE_STATIC (decl) && type != error_mark_node)
8068         {
8069           /* Cleanups for static variables are handled by `finish_file'.  */
8070           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8071               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8072             expand_static_init (decl, init);
8073         }
8074     finish_end0:
8075
8076       /* Undo call to `pushclass' that was done in `start_decl'
8077          due to initialization of qualified member variable.
8078          I.e., Foo::x = 10;  */
8079       {
8080         tree context = CP_DECL_CONTEXT (decl);
8081         if (context
8082             && TYPE_P (context)
8083             && (TREE_CODE (decl) == VAR_DECL
8084                 /* We also have a pushclass done that we need to undo here
8085                    if we're at top level and declare a method.  */
8086                 || TREE_CODE (decl) == FUNCTION_DECL)
8087             /* If size hasn't been set, we're still defining it,
8088                and therefore inside the class body; don't pop
8089                the binding level..  */
8090             && COMPLETE_TYPE_P (context)
8091             && context == current_class_type)
8092           pop_nested_class ();
8093       }
8094     }
8095
8096  finish_end:
8097
8098   if (was_readonly)
8099     TREE_READONLY (decl) = 1;
8100 }
8101
8102 /* This is here for a midend callback from c-common.c */
8103
8104 void
8105 finish_decl (decl, init, asmspec_tree)
8106      tree decl, init;
8107      tree asmspec_tree;
8108 {
8109   cp_finish_decl (decl, init, asmspec_tree, 0);
8110 }
8111
8112 /* Returns a declaration for a VAR_DECL as if:
8113
8114      extern "C" TYPE NAME;
8115
8116    had been seen.  Used to create compiler-generated global
8117    variables.  */
8118
8119 tree
8120 declare_global_var (name, type)
8121      tree name;
8122      tree type;
8123 {
8124   tree decl;
8125
8126   push_to_top_level ();
8127   decl = build_decl (VAR_DECL, name, type);
8128   TREE_PUBLIC (decl) = 1;
8129   DECL_EXTERNAL (decl) = 1;
8130   DECL_ARTIFICIAL (decl) = 1;
8131   pushdecl (decl);
8132   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8133   pop_from_top_level ();
8134
8135   return decl;
8136 }
8137
8138 /* Returns a pointer to the `atexit' function.  Note that if
8139    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8140    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8141
8142 static tree
8143 get_atexit_node ()
8144 {
8145   tree atexit_fndecl;
8146   tree arg_types;
8147   tree fn_type;
8148   tree fn_ptr_type;
8149   const char *name;
8150
8151   if (atexit_node)
8152     return atexit_node;
8153
8154   if (flag_use_cxa_atexit)
8155     {
8156       /* The declaration for `__cxa_atexit' is:
8157
8158            int __cxa_atexit (void (*)(void *), void *, void *)
8159
8160          We build up the argument types and then then function type
8161          itself.  */
8162
8163       /* First, build the pointer-to-function type for the first
8164          argument.  */
8165       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8166       fn_type = build_function_type (void_type_node, arg_types);
8167       fn_ptr_type = build_pointer_type (fn_type);
8168       /* Then, build the rest of the argument types.  */
8169       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8170       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8171       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8172       /* And the final __cxa_atexit type.  */
8173       fn_type = build_function_type (integer_type_node, arg_types);
8174       fn_ptr_type = build_pointer_type (fn_type);
8175       name = "__cxa_atexit";
8176     }
8177   else
8178     {
8179       /* The declaration for `atexit' is:
8180
8181            int atexit (void (*)());
8182
8183          We build up the argument types and then then function type
8184          itself.  */
8185       fn_type = build_function_type (void_type_node, void_list_node);
8186       fn_ptr_type = build_pointer_type (fn_type);
8187       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8188       /* Build the final atexit type.  */
8189       fn_type = build_function_type (integer_type_node, arg_types);
8190       name = "atexit";
8191     }
8192
8193   /* Now, build the function declaration.  */
8194   push_lang_context (lang_name_c);
8195   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8196   mark_used (atexit_fndecl);
8197   pop_lang_context ();
8198   atexit_node = default_conversion (atexit_fndecl);
8199
8200   return atexit_node;
8201 }
8202
8203 /* Returns the __dso_handle VAR_DECL.  */
8204
8205 static tree
8206 get_dso_handle_node ()
8207 {
8208   if (dso_handle_node)
8209     return dso_handle_node;
8210
8211   /* Declare the variable.  */
8212   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8213                                         ptr_type_node);
8214
8215   return dso_handle_node;
8216 }
8217
8218 /* Begin a new function with internal linkage whose job will be simply
8219    to destroy some particular variable.  */
8220
8221 static tree
8222 start_cleanup_fn ()
8223 {
8224   static int counter = 0;
8225   int old_interface_unknown = interface_unknown;
8226   char name[32];
8227   tree parmtypes;
8228   tree fntype;
8229   tree fndecl;
8230
8231   push_to_top_level ();
8232
8233   /* No need to mangle this.  */
8234   push_lang_context (lang_name_c);
8235
8236   interface_unknown = 1;
8237
8238   /* Build the parameter-types.  */
8239   parmtypes = void_list_node;
8240   /* Functions passed to __cxa_atexit take an additional parameter.
8241      We'll just ignore it.  After we implement the new calling
8242      convention for destructors, we can eliminate the use of
8243      additional cleanup functions entirely in the -fnew-abi case.  */
8244   if (flag_use_cxa_atexit)
8245     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8246   /* Build the function type itself.  */
8247   fntype = build_function_type (void_type_node, parmtypes);
8248   /* Build the name of the function.  */
8249   sprintf (name, "__tcf_%d", counter++);
8250   /* Build the function declaration.  */
8251   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8252   /* It's a function with internal linkage, generated by the
8253      compiler.  */
8254   TREE_PUBLIC (fndecl) = 0;
8255   DECL_ARTIFICIAL (fndecl) = 1;
8256   /* Build the parameter.  */
8257   if (flag_use_cxa_atexit)
8258     {
8259       tree parmdecl;
8260
8261       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8262       DECL_CONTEXT (parmdecl) = fndecl;
8263       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8264       TREE_USED (parmdecl) = 1;
8265       DECL_ARGUMENTS (fndecl) = parmdecl;
8266     }
8267
8268   pushdecl (fndecl);
8269   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8270   do_pushlevel ();
8271
8272   interface_unknown = old_interface_unknown;
8273
8274   pop_lang_context ();
8275
8276   return current_function_decl;
8277 }
8278
8279 /* Finish the cleanup function begun by start_cleanup_fn.  */
8280
8281 static void
8282 end_cleanup_fn ()
8283 {
8284   do_poplevel ();
8285
8286   expand_body (finish_function (0));
8287
8288   pop_from_top_level ();
8289 }
8290
8291 /* Generate code to handle the destruction of DECL, an object with
8292    static storage duration.  */
8293
8294 void
8295 register_dtor_fn (decl)
8296      tree decl;
8297 {
8298   tree cleanup;
8299   tree compound_stmt;
8300   tree args;
8301   tree fcall;
8302
8303   int saved_flag_access_control;
8304
8305   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8306     return;
8307
8308   /* Call build_cleanup before we enter the anonymous function so that
8309      any access checks will be done relative to the current scope,
8310      rather than the scope of the anonymous function.  */
8311   build_cleanup (decl);
8312
8313   /* Now start the function.  */
8314   cleanup = start_cleanup_fn ();
8315
8316   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8317      to the original function, rather than the anonymous one.  That
8318      will make the back-end think that nested functions are in use,
8319      which causes confusion.  */
8320   saved_flag_access_control = flag_access_control;
8321   flag_access_control = 0;
8322   fcall = build_cleanup (decl);
8323   flag_access_control = saved_flag_access_control;
8324
8325   /* Create the body of the anonymous function.  */
8326   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8327   finish_expr_stmt (fcall);
8328   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8329   end_cleanup_fn ();
8330
8331   /* Call atexit with the cleanup function.  */
8332   mark_addressable (cleanup);
8333   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8334   if (flag_use_cxa_atexit)
8335     {
8336       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8337       args = tree_cons (NULL_TREE, null_pointer_node, args);
8338       args = tree_cons (NULL_TREE, cleanup, args);
8339     }
8340   else
8341     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8342   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8343 }
8344
8345 void
8346 expand_static_init (decl, init)
8347      tree decl;
8348      tree init;
8349 {
8350   tree oldstatic = value_member (decl, static_aggregates);
8351
8352   if (oldstatic)
8353     {
8354       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8355         cp_error ("multiple initializations given for `%D'", decl);
8356     }
8357   else if (! toplevel_bindings_p ())
8358     {
8359       /* Emit code to perform this initialization but once.  */
8360       tree temp;
8361       tree if_stmt;
8362       tree then_clause;
8363       tree assignment;
8364       tree temp_init;
8365
8366       /* Emit code to perform this initialization but once.  This code
8367          looks like:
8368
8369            static int temp = 0;
8370            if (!temp) {
8371              // Do initialization.
8372              temp = 1;
8373              // Register variable for destruction at end of program.
8374            }
8375
8376          Note that the `temp' variable is only set to 1 *after* the
8377          initialization is complete.  This ensures that an exception,
8378          thrown during the construction, will cause the variable to
8379          reinitialized when we pass through this code again, as per:
8380
8381            [stmt.dcl]
8382
8383            If the initialization exits by throwing an exception, the
8384            initialization is not complete, so it will be tried again
8385            the next time control enters the declaration.
8386
8387          In theory, this process should be thread-safe, too; multiple
8388          threads should not be able to initialize the variable more
8389          than once.  We don't yet attempt to ensure thread-safety.  */
8390       temp = get_temp_name (integer_type_node, 1);
8391       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8392
8393       /* Begin the conditional initialization.  */
8394       if_stmt = begin_if_stmt ();
8395       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8396                                             integer_zero_node),
8397                            if_stmt);
8398       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8399
8400       /* Do the initialization itself.  */
8401       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8402           || (init && TREE_CODE (init) == TREE_LIST))
8403         assignment = build_aggr_init (decl, init, 0);
8404       else if (init)
8405         /* The initialization we're doing here is just a bitwise
8406            copy.  */
8407         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8408       else
8409         assignment = NULL_TREE;
8410
8411       /* Once the assignment is complete, set TEMP to 1.  Since the
8412          construction of the static object is complete at this point,
8413          we want to make sure TEMP is set to 1 even if a temporary
8414          constructed during the initialization throws an exception
8415          when it is destroyed.  So, we combine the initialization and
8416          the assignment to TEMP into a single expression, ensuring
8417          that when we call finish_expr_stmt the cleanups will not be
8418          run until after TEMP is set to 1.  */
8419       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8420       if (assignment)
8421         {
8422           assignment = tree_cons (NULL_TREE, assignment,
8423                                   build_tree_list (NULL_TREE,
8424                                                    temp_init));
8425           assignment = build_compound_expr (assignment);
8426         }
8427       else
8428         assignment = temp_init;
8429       finish_expr_stmt (assignment);
8430
8431       /* Use atexit to register a function for destroying this static
8432          variable.  */
8433       register_dtor_fn (decl);
8434
8435       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8436       finish_then_clause (if_stmt);
8437       finish_if_stmt ();
8438     }
8439   else
8440     static_aggregates = tree_cons (init, decl, static_aggregates);
8441 }
8442
8443 /* Finish the declaration of a catch-parameter.  */
8444
8445 tree
8446 start_handler_parms (declspecs, declarator)
8447      tree declspecs;
8448      tree declarator;
8449 {
8450   tree decl;
8451   if (declspecs)
8452     {
8453       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8454                              1, NULL_TREE);
8455       if (decl == NULL_TREE)
8456         error ("invalid catch parameter");
8457     }
8458   else
8459     decl = NULL_TREE;
8460
8461   return decl;
8462 }
8463
8464 \f
8465 /* Make TYPE a complete type based on INITIAL_VALUE.
8466    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8467    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8468
8469 int
8470 complete_array_type (type, initial_value, do_default)
8471      tree type, initial_value;
8472      int do_default;
8473 {
8474   register tree maxindex = NULL_TREE;
8475   int value = 0;
8476
8477   if (initial_value)
8478     {
8479       /* Note MAXINDEX  is really the maximum index,
8480          one less than the size.  */
8481       if (TREE_CODE (initial_value) == STRING_CST)
8482         {
8483           int eltsize
8484             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8485           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8486                                    / eltsize) - 1, 0);
8487         }
8488       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8489         {
8490           tree elts = CONSTRUCTOR_ELTS (initial_value);
8491
8492           maxindex = ssize_int (-1);
8493           for (; elts; elts = TREE_CHAIN (elts))
8494             {
8495               if (TREE_PURPOSE (elts))
8496                 maxindex = TREE_PURPOSE (elts);
8497               else
8498                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8499             }
8500           maxindex = copy_node (maxindex);
8501         }
8502       else
8503         {
8504           /* Make an error message unless that happened already.  */
8505           if (initial_value != error_mark_node)
8506             value = 1;
8507           else
8508             initial_value = NULL_TREE;
8509
8510           /* Prevent further error messages.  */
8511           maxindex = build_int_2 (0, 0);
8512         }
8513     }
8514
8515   if (!maxindex)
8516     {
8517       if (do_default)
8518         maxindex = build_int_2 (0, 0);
8519       value = 2;
8520     }
8521
8522   if (maxindex)
8523     {
8524       tree itype;
8525       tree domain;
8526
8527       domain = build_index_type (maxindex);
8528       TYPE_DOMAIN (type) = domain;
8529
8530       if (! TREE_TYPE (maxindex))
8531         TREE_TYPE (maxindex) = domain;
8532       if (initial_value)
8533         itype = TREE_TYPE (initial_value);
8534       else
8535         itype = NULL;
8536       if (itype && !TYPE_DOMAIN (itype))
8537         TYPE_DOMAIN (itype) = domain;
8538       /* The type of the main variant should never be used for arrays
8539          of different sizes.  It should only ever be completed with the
8540          size of the array.  */
8541       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8542         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8543     }
8544
8545   /* Lay out the type now that we can get the real answer.  */
8546
8547   layout_type (type);
8548
8549   return value;
8550 }
8551 \f
8552 /* Return zero if something is declared to be a member of type
8553    CTYPE when in the context of CUR_TYPE.  STRING is the error
8554    message to print in that case.  Otherwise, quietly return 1.  */
8555
8556 static int
8557 member_function_or_else (ctype, cur_type, flags)
8558      tree ctype, cur_type;
8559      enum overload_flags flags;
8560 {
8561   if (ctype && ctype != cur_type)
8562     {
8563       if (flags == DTOR_FLAG)
8564         error ("destructor for alien class `%s' cannot be a member",
8565                TYPE_NAME_STRING (ctype));
8566       else
8567         error ("constructor for alien class `%s' cannot be a member",
8568                TYPE_NAME_STRING (ctype));
8569       return 0;
8570     }
8571   return 1;
8572 }
8573 \f
8574 /* Subroutine of `grokdeclarator'.  */
8575
8576 /* Generate errors possibly applicable for a given set of specifiers.
8577    This is for ARM $7.1.2.  */
8578
8579 static void
8580 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8581      tree object;
8582      const char *type;
8583      int virtualp, quals, friendp, raises, inlinep;
8584 {
8585   if (virtualp)
8586     cp_error ("`%D' declared as a `virtual' %s", object, type);
8587   if (inlinep)
8588     cp_error ("`%D' declared as an `inline' %s", object, type);
8589   if (quals)
8590     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8591               object, type);
8592   if (friendp)
8593     cp_error_at ("`%D' declared as a friend", object);
8594   if (raises)
8595     cp_error_at ("`%D' declared with an exception specification", object);
8596 }
8597
8598 /* CTYPE is class type, or null if non-class.
8599    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8600    or METHOD_TYPE.
8601    DECLARATOR is the function's name.
8602    VIRTUALP is truthvalue of whether the function is virtual or not.
8603    FLAGS are to be passed through to `grokclassfn'.
8604    QUALS are qualifiers indicating whether the function is `const'
8605    or `volatile'.
8606    RAISES is a list of exceptions that this function can raise.
8607    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8608    not look, and -1 if we should not call `grokclassfn' at all.
8609
8610    Returns `NULL_TREE' if something goes wrong, after issuing
8611    applicable error messages.  */
8612
8613 static tree
8614 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8615             raises, check, friendp, publicp, inlinep, funcdef_flag,
8616             template_count, in_namespace)
8617      tree ctype, type;
8618      tree declarator;
8619      tree orig_declarator;
8620      int virtualp;
8621      enum overload_flags flags;
8622      tree quals, raises;
8623      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8624      tree in_namespace;
8625 {
8626   tree cname, decl;
8627   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8628   int has_default_arg = 0;
8629   tree t;
8630
8631   if (ctype)
8632     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8633       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8634   else
8635     cname = NULL_TREE;
8636
8637   if (raises)
8638     {
8639       type = build_exception_variant (type, raises);
8640     }
8641
8642   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8643   /* Propagate volatile out from type to decl. */
8644   if (TYPE_VOLATILE (type))
8645     TREE_THIS_VOLATILE (decl) = 1;
8646
8647   /* If this decl has namespace scope, set that up.  */
8648   if (in_namespace)
8649     set_decl_namespace (decl, in_namespace, friendp);
8650   else if (publicp && ! ctype)
8651     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8652
8653   /* `main' and builtins have implicit 'C' linkage.  */
8654   if ((MAIN_NAME_P (declarator)
8655        || (IDENTIFIER_LENGTH (declarator) > 10
8656            && IDENTIFIER_POINTER (declarator)[0] == '_'
8657            && IDENTIFIER_POINTER (declarator)[1] == '_'
8658            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8659       && current_lang_name == lang_name_cplusplus
8660       && ctype == NULL_TREE
8661       /* NULL_TREE means global namespace.  */
8662       && DECL_CONTEXT (decl) == NULL_TREE)
8663     DECL_LANGUAGE (decl) = lang_c;
8664
8665   /* Should probably propagate const out from type to decl I bet (mrs).  */
8666   if (staticp)
8667     {
8668       DECL_STATIC_FUNCTION_P (decl) = 1;
8669       DECL_CONTEXT (decl) = ctype;
8670     }
8671
8672   if (ctype)
8673     DECL_CONTEXT (decl) = ctype;
8674
8675   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8676     {
8677       if (processing_template_decl)
8678         error ("cannot declare `::main' to be a template");
8679       if (inlinep)
8680         error ("cannot declare `::main' to be inline");
8681       else if (! publicp)
8682         error ("cannot declare `::main' to be static");
8683       inlinep = 0;
8684       publicp = 1;
8685     }
8686
8687   /* Members of anonymous types and local classes have no linkage; make
8688      them internal.  */
8689   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8690                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8691     publicp = 0;
8692
8693   if (publicp)
8694     {
8695       /* [basic.link]: A name with no linkage (notably, the name of a class
8696          or enumeration declared in a local scope) shall not be used to
8697          declare an entity with linkage.
8698
8699          Only check this for public decls for now.  */
8700       t = no_linkage_check (TREE_TYPE (decl));
8701       if (t)
8702         {
8703           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8704             {
8705               if (DECL_LANGUAGE (decl) == lang_c)
8706                 /* Allow this; it's pretty common in C.  */;
8707               else
8708                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8709                             decl);
8710             }
8711           else
8712             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8713                         decl, t);
8714         }
8715     }
8716
8717   TREE_PUBLIC (decl) = publicp;
8718   if (! publicp)
8719     {
8720       DECL_INTERFACE_KNOWN (decl) = 1;
8721       DECL_NOT_REALLY_EXTERN (decl) = 1;
8722     }
8723
8724   if (inlinep)
8725     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8726
8727   DECL_EXTERNAL (decl) = 1;
8728   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8729     {
8730       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8731                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8732       quals = NULL_TREE;
8733     }
8734
8735   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8736     grok_op_properties (decl, virtualp, check < 0);
8737
8738   if (ctype && decl_function_context (decl))
8739     DECL_NO_STATIC_CHAIN (decl) = 1;
8740
8741   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8742     if (TREE_PURPOSE (t)
8743         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8744       {
8745         has_default_arg = 1;
8746         break;
8747       }
8748
8749   if (friendp
8750       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8751     {
8752       if (funcdef_flag)
8753         cp_error
8754           ("defining explicit specialization `%D' in friend declaration",
8755            orig_declarator);
8756       else
8757         {
8758           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8759             {
8760               /* Something like `template <class T> friend void f<T>()'.  */
8761               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8762                         orig_declarator);
8763               return NULL_TREE;
8764             }
8765
8766
8767           /* A friend declaration of the form friend void f<>().  Record
8768              the information in the TEMPLATE_ID_EXPR.  */
8769           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8770           DECL_TEMPLATE_INFO (decl)
8771             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8772                          TREE_OPERAND (orig_declarator, 1),
8773                          NULL_TREE);
8774
8775           if (has_default_arg)
8776             {
8777               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8778                         decl);
8779               return NULL_TREE;
8780             }
8781
8782           if (inlinep)
8783             {
8784               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8785                         decl);
8786               return NULL_TREE;
8787             }
8788         }
8789     }
8790
8791   if (has_default_arg)
8792     add_defarg_fn (decl);
8793
8794   /* Plain overloading: will not be grok'd by grokclassfn.  */
8795   if (! ctype && ! processing_template_decl
8796       && DECL_LANGUAGE (decl) != lang_c
8797       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8798     set_mangled_name_for_decl (decl);
8799
8800   if (funcdef_flag)
8801     /* Make the init_value nonzero so pushdecl knows this is not
8802        tentative.  error_mark_node is replaced later with the BLOCK.  */
8803     DECL_INITIAL (decl) = error_mark_node;
8804
8805   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8806     TREE_NOTHROW (decl) = 1;
8807
8808   /* Caller will do the rest of this.  */
8809   if (check < 0)
8810     return decl;
8811
8812   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8813     DECL_CONSTRUCTOR_P (decl) = 1;
8814
8815   /* Function gets the ugly name, field gets the nice one.  This call
8816      may change the type of the function (because of default
8817      parameters)!  */
8818   if (ctype != NULL_TREE)
8819     grokclassfn (ctype, decl, flags, quals);
8820
8821   decl = check_explicit_specialization (orig_declarator, decl,
8822                                         template_count,
8823                                         2 * (funcdef_flag != 0) +
8824                                         4 * (friendp != 0));
8825   if (decl == error_mark_node)
8826     return NULL_TREE;
8827
8828   if (ctype != NULL_TREE
8829       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8830       && check)
8831     {
8832       tree old_decl;
8833
8834       old_decl = check_classfn (ctype, decl);
8835
8836       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8837         /* Because grokfndecl is always supposed to return a
8838            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8839            here.  We depend on our callers to figure out that its
8840            really a template that's being returned.  */
8841         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8842
8843       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8844           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8845         {
8846           /* Remove the `this' parm added by grokclassfn.
8847              XXX Isn't this done in start_function, too?  */
8848           revert_static_member_fn (decl);
8849           last_function_parms = TREE_CHAIN (last_function_parms);
8850         }
8851       if (old_decl && DECL_ARTIFICIAL (old_decl))
8852         cp_error ("definition of implicitly-declared `%D'", old_decl);
8853
8854       if (old_decl)
8855         {
8856           /* Since we've smashed OLD_DECL to its
8857              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8858           if (TREE_CODE (decl) == TEMPLATE_DECL)
8859             decl = DECL_TEMPLATE_RESULT (decl);
8860
8861           /* Attempt to merge the declarations.  This can fail, in
8862              the case of some illegal specialization declarations.  */
8863           if (!duplicate_decls (decl, old_decl))
8864             cp_error ("no `%#D' member function declared in class `%T'",
8865                       decl, ctype);
8866           return old_decl;
8867         }
8868     }
8869
8870   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8871     return NULL_TREE;
8872
8873   if (ctype == NULL_TREE || check)
8874     return decl;
8875
8876   if (virtualp)
8877     {
8878       DECL_VIRTUAL_P (decl) = 1;
8879       if (DECL_VINDEX (decl) == NULL_TREE)
8880         DECL_VINDEX (decl) = error_mark_node;
8881       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8882     }
8883
8884   return decl;
8885 }
8886
8887 static tree
8888 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8889      tree type;
8890      tree declarator;
8891      RID_BIT_TYPE *specbits_in;
8892      int initialized;
8893      int constp;
8894      tree in_namespace;
8895 {
8896   tree decl;
8897   RID_BIT_TYPE specbits;
8898
8899   specbits = *specbits_in;
8900
8901   if (TREE_CODE (type) == OFFSET_TYPE)
8902     {
8903       /* If you declare a static member so that it
8904          can be initialized, the code will reach here.  */
8905       tree basetype = TYPE_OFFSET_BASETYPE (type);
8906       type = TREE_TYPE (type);
8907       decl = build_lang_decl (VAR_DECL, declarator, type);
8908       DECL_CONTEXT (decl) = basetype;
8909       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8910     }
8911   else
8912     {
8913       tree context;
8914
8915       if (in_namespace)
8916         context = in_namespace;
8917       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8918         context = current_namespace;
8919       else
8920         context = NULL_TREE;
8921
8922       if (processing_template_decl)
8923         /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8924            we can call push_template_decl.  */
8925         decl = build_lang_decl (VAR_DECL, declarator, type);
8926       else
8927         decl = build_decl (VAR_DECL, declarator, type);
8928
8929       if (context)
8930         set_decl_namespace (decl, context, 0);
8931
8932       context = DECL_CONTEXT (decl);
8933       if (declarator && context && current_lang_name != lang_name_c)
8934         DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8935     }
8936
8937   if (in_namespace)
8938     set_decl_namespace (decl, in_namespace, 0);
8939
8940   if (RIDBIT_SETP (RID_EXTERN, specbits))
8941     {
8942       DECL_THIS_EXTERN (decl) = 1;
8943       DECL_EXTERNAL (decl) = !initialized;
8944     }
8945
8946   /* In class context, static means one per class,
8947      public access, and static storage.  */
8948   if (DECL_CLASS_SCOPE_P (decl))
8949     {
8950       TREE_PUBLIC (decl) = 1;
8951       TREE_STATIC (decl) = 1;
8952       DECL_EXTERNAL (decl) = 0;
8953     }
8954   /* At top level, either `static' or no s.c. makes a definition
8955      (perhaps tentative), and absence of `static' makes it public.  */
8956   else if (toplevel_bindings_p ())
8957     {
8958       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8959                             && (DECL_THIS_EXTERN (decl) || ! constp));
8960       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8961     }
8962   /* Not at top level, only `static' makes a static definition.  */
8963   else
8964     {
8965       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8966       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8967     }
8968
8969   if (TREE_PUBLIC (decl))
8970     {
8971       /* [basic.link]: A name with no linkage (notably, the name of a class
8972          or enumeration declared in a local scope) shall not be used to
8973          declare an entity with linkage.
8974
8975          Only check this for public decls for now.  */
8976       tree t = no_linkage_check (TREE_TYPE (decl));
8977       if (t)
8978         {
8979           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8980             /* Ignore for now; `enum { foo } e' is pretty common.  */;
8981           else
8982             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8983                         decl, t);
8984         }
8985     }
8986
8987   return decl;
8988 }
8989
8990 /* Create and return a canonical pointer to member function type, for
8991    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
8992
8993 tree
8994 build_ptrmemfunc_type (type)
8995      tree type;
8996 {
8997   tree fields[4];
8998   tree t;
8999   tree u;
9000   tree unqualified_variant = NULL_TREE;
9001
9002   /* If a canonical type already exists for this type, use it.  We use
9003      this method instead of type_hash_canon, because it only does a
9004      simple equality check on the list of field members.  */
9005
9006   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9007     return t;
9008
9009   /* Make sure that we always have the unqualified pointer-to-member
9010      type first.  */
9011   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9012     unqualified_variant
9013       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9014
9015   t = make_aggr_type (RECORD_TYPE);
9016   /* Let the front-end know this is a pointer to member function...  */
9017   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9018   /* ... and not really an aggregate.  */
9019   SET_IS_AGGR_TYPE (t, 0);
9020
9021   if (!flag_new_abi)
9022     {
9023       u = make_aggr_type (UNION_TYPE);
9024       SET_IS_AGGR_TYPE (u, 0);
9025       fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
9026       fields[1] = build_lang_decl (FIELD_DECL, delta2_identifier,
9027                                    delta_type_node);
9028       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9029       TYPE_NAME (u) = NULL_TREE;
9030
9031       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
9032                                    delta_type_node);
9033       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
9034                                    delta_type_node);
9035       fields[2] = build_lang_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9036       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9037     }
9038   else
9039     {
9040       fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
9041       fields[1] = build_lang_decl (FIELD_DECL, delta_identifier,
9042                                    delta_type_node);
9043       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9044     }
9045
9046   /* Zap out the name so that the back-end will give us the debugging
9047      information for this anonymous RECORD_TYPE.  */
9048   TYPE_NAME (t) = NULL_TREE;
9049
9050   /* If this is not the unqualified form of this pointer-to-member
9051      type, set the TYPE_MAIN_VARIANT for this type to be the
9052      unqualified type.  Since they are actually RECORD_TYPEs that are
9053      not variants of each other, we must do this manually.  */
9054   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9055     {
9056       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9057       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9058       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9059       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9060     }
9061
9062   /* Cache this pointer-to-member type so that we can find it again
9063      later.  */
9064   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9065
9066   /* Seems to be wanted.  */
9067   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9068
9069   return t;
9070 }
9071
9072 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9073    Check to see that the definition is valid.  Issue appropriate error
9074    messages.  Return 1 if the definition is particularly bad, or 0
9075    otherwise.  */
9076
9077 int
9078 check_static_variable_definition (decl, type)
9079      tree decl;
9080      tree type;
9081 {
9082   /* Motion 10 at San Diego: If a static const integral data member is
9083      initialized with an integral constant expression, the initializer
9084      may appear either in the declaration (within the class), or in
9085      the definition, but not both.  If it appears in the class, the
9086      member is a member constant.  The file-scope definition is always
9087      required.  */
9088   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9089     {
9090       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9091                 type);
9092       /* If we just return the declaration, crashes will sometimes
9093          occur.  We therefore return void_type_node, as if this was a
9094          friend declaration, to cause callers to completely ignore
9095          this declaration.  */
9096       return 1;
9097     }
9098   else if (!CP_TYPE_CONST_P (type))
9099     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9100               decl);
9101   else if (pedantic && !INTEGRAL_TYPE_P (type))
9102     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9103
9104   return 0;
9105 }
9106
9107 /* Given the SIZE (i.e., number of elements) in an array, compute an
9108    appropriate index type for the array.  If non-NULL, NAME is the
9109    name of the thing being declared.  */
9110
9111 tree
9112 compute_array_index_type (name, size)
9113      tree name;
9114      tree size;
9115 {
9116   tree itype;
9117
9118   /* The size might be the result of a cast. */
9119   STRIP_TYPE_NOPS (size);
9120
9121   /* It might be a const variable or enumeration constant.  */
9122   if (TREE_READONLY_DECL_P (size))
9123     size = decl_constant_value (size);
9124
9125   /* If this involves a template parameter, it will be a constant at
9126      instantiation time, but we don't know what the value is yet.
9127      Even if no template parameters are involved, we may an expression
9128      that is not a constant; we don't even simplify `1 + 2' when
9129      processing a template.  */
9130   if (processing_template_decl)
9131     {
9132       /* Resolve a qualified reference to an enumerator or static
9133          const data member of ours.  */
9134       if (TREE_CODE (size) == SCOPE_REF
9135           && TREE_OPERAND (size, 0) == current_class_type)
9136         {
9137           tree t = lookup_field (current_class_type,
9138                                  TREE_OPERAND (size, 1), 0, 0);
9139           if (t)
9140             size = t;
9141         }
9142
9143       return build_index_type (build_min (MINUS_EXPR, sizetype,
9144                                           size, integer_one_node));
9145     }
9146
9147   /* The array bound must be an integer type.  */
9148   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9149       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9150       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9151     {
9152       if (name)
9153         cp_error ("size of array `%D' has non-integer type", name);
9154       else
9155         cp_error ("size of array has non-integer type");
9156       size = integer_one_node;
9157     }
9158
9159   /* Normally, the array-bound will be a constant.  */
9160   if (TREE_CONSTANT (size))
9161     {
9162       /* Check to see if the array bound overflowed.  Make that an
9163          error, no matter how generous we're being.  */
9164       int old_flag_pedantic_errors = flag_pedantic_errors;
9165       int old_pedantic = pedantic;
9166       pedantic = flag_pedantic_errors = 1;
9167       constant_expression_warning (size);
9168       pedantic = old_pedantic;
9169       flag_pedantic_errors = old_flag_pedantic_errors;
9170
9171       /* An array must have a positive number of elements.  */
9172       if (INT_CST_LT (size, integer_zero_node))
9173         {
9174           if (name)
9175             cp_error ("size of array `%D' is negative", name);
9176           else
9177             cp_error ("size of array is negative");
9178           size = integer_one_node;
9179         }
9180       /* Except that an extension we allow zero-sized arrays.  We
9181          always allow them in system headers because glibc uses
9182          them.  */
9183       else if (integer_zerop (size) && pedantic && !in_system_header)
9184         {
9185           if (name)
9186             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9187           else
9188             cp_pedwarn ("ISO C++ forbids zero-size array");
9189         }
9190     }
9191
9192   /* Compute the index of the largest element in the array.  It is
9193      one less than the number of elements in the array.  */
9194   itype
9195     = fold (build_binary_op (MINUS_EXPR,
9196                              cp_convert (ssizetype, size),
9197                              cp_convert (ssizetype,
9198                                          integer_one_node)));
9199
9200   /* Check for variable-sized arrays.  We allow such things as an
9201      extension, even though they are not allowed in ANSI/ISO C++.  */
9202   if (!TREE_CONSTANT (itype))
9203     {
9204       if (pedantic)
9205         {
9206           if (name)
9207             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9208                         name);
9209           else
9210             cp_pedwarn ("ISO C++ forbids variable-size array");
9211         }
9212
9213       /* Create a variable-sized array index type.  */
9214       itype = variable_size (itype);
9215     }
9216   /* Make sure that there was no overflow when creating to a signed
9217      index type.  (For example, on a 32-bit machine, an array with
9218      size 2^32 - 1 is too big.)  */
9219   else if (TREE_OVERFLOW (itype))
9220     {
9221       error ("overflow in array dimension");
9222       TREE_OVERFLOW (itype) = 0;
9223     }
9224
9225   /* Create and return the appropriate index type.  */
9226   return build_index_type (itype);
9227 }
9228
9229 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9230    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9231    with this type.  */
9232
9233 static tree
9234 create_array_type_for_decl (name, type, size)
9235      tree name;
9236      tree type;
9237      tree size;
9238 {
9239   tree itype = NULL_TREE;
9240   const char* error_msg;
9241
9242   /* If things have already gone awry, bail now.  */
9243   if (type == error_mark_node || size == error_mark_node)
9244     return error_mark_node;
9245
9246   /* Assume that everything will go OK.  */
9247   error_msg = NULL;
9248
9249   /* There are some types which cannot be array elements.  */
9250   switch (TREE_CODE (type))
9251     {
9252     case VOID_TYPE:
9253       error_msg = "array of void";
9254       break;
9255
9256     case FUNCTION_TYPE:
9257       error_msg = "array of functions";
9258       break;
9259
9260     case REFERENCE_TYPE:
9261       error_msg = "array of references";
9262       break;
9263
9264     case OFFSET_TYPE:
9265       error_msg = "array of data members";
9266       break;
9267
9268     case METHOD_TYPE:
9269       error_msg = "array of function members";
9270       break;
9271
9272     default:
9273       break;
9274     }
9275
9276   /* If something went wrong, issue an error-message and return.  */
9277   if (error_msg)
9278     {
9279       if (name)
9280         cp_error ("declaration of `%D' as %s", name, error_msg);
9281       else
9282         cp_error ("creating %s", error_msg);
9283
9284       return error_mark_node;
9285     }
9286
9287   /* [dcl.array]
9288
9289      The constant expressions that specify the bounds of the arrays
9290      can be omitted only for the first member of the sequence.  */
9291   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9292     {
9293       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9294                 name);
9295
9296       return error_mark_node;
9297     }
9298
9299   /* Figure out the index type for the array.  */
9300   if (size)
9301     itype = compute_array_index_type (name, size);
9302
9303   return build_cplus_array_type (type, itype);
9304 }
9305
9306 /* Check that it's OK to declare a function with the indicated TYPE.
9307    SFK indicates the kind of special function (if any) that this
9308    function is.  CTYPE is the class of which this function is a
9309    member.  OPTYPE is the type given in a conversion operator
9310    declaration.  Returns the actual return type of the function; that
9311    may be different than TYPE if an error occurs, or for certain
9312    special functions.  */
9313
9314 static tree
9315 check_special_function_return_type (sfk, type, ctype, optype)
9316      special_function_kind sfk;
9317      tree type;
9318      tree ctype;
9319      tree optype;
9320 {
9321   switch (sfk)
9322     {
9323     case sfk_constructor:
9324       if (type)
9325         cp_error ("return type specification for constructor invalid");
9326
9327       /* In the old ABI, we return `this'; in the new ABI we don't
9328          bother.  */
9329       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9330       break;
9331
9332     case sfk_destructor:
9333       if (type)
9334         cp_error ("return type specification for destructor invalid");
9335       type = void_type_node;
9336       break;
9337
9338     case sfk_conversion:
9339       if (type && !same_type_p (type, optype))
9340         cp_error ("operator `%T' declared to return `%T'", optype, type);
9341       else if (type)
9342         cp_pedwarn ("return type specified for `operator %T'",  optype);
9343       type = optype;
9344       break;
9345
9346     default:
9347       my_friendly_abort (20000408);
9348       break;
9349     }
9350
9351   return type;
9352 }
9353
9354 /* Given declspecs and a declarator,
9355    determine the name and type of the object declared
9356    and construct a ..._DECL node for it.
9357    (In one case we can return a ..._TYPE node instead.
9358     For invalid input we sometimes return 0.)
9359
9360    DECLSPECS is a chain of tree_list nodes whose value fields
9361     are the storage classes and type specifiers.
9362
9363    DECL_CONTEXT says which syntactic context this declaration is in:
9364      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9365      FUNCDEF for a function definition.  Like NORMAL but a few different
9366       error messages in each case.  Return value may be zero meaning
9367       this definition is too screwy to try to parse.
9368      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9369       handle member functions (which have FIELD context).
9370       Return value may be zero meaning this definition is too screwy to
9371       try to parse.
9372      PARM for a parameter declaration (either within a function prototype
9373       or before a function body).  Make a PARM_DECL, or return void_type_node.
9374      CATCHPARM for a parameter declaration before a catch clause.
9375      TYPENAME if for a typename (in a cast or sizeof).
9376       Don't make a DECL node; just return the ..._TYPE node.
9377      FIELD for a struct or union field; make a FIELD_DECL.
9378      BITFIELD for a field with specified width.
9379    INITIALIZED is 1 if the decl has an initializer.
9380
9381    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9382    normal attributes in TREE_PURPOSE, or NULL_TREE.
9383
9384    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9385    It may also be so in the PARM case, for a prototype where the
9386    argument type is specified but not the name.
9387
9388    This function is where the complicated C meanings of `static'
9389    and `extern' are interpreted.
9390
9391    For C++, if there is any monkey business to do, the function which
9392    calls this one must do it, i.e., prepending instance variables,
9393    renaming overloaded function names, etc.
9394
9395    Note that for this C++, it is an error to define a method within a class
9396    which does not belong to that class.
9397
9398    Except in the case where SCOPE_REFs are implicitly known (such as
9399    methods within a class being redundantly qualified),
9400    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9401    (class_name::decl_name).  The caller must also deal with this.
9402
9403    If a constructor or destructor is seen, and the context is FIELD,
9404    then the type gains the attribute TREE_HAS_x.  If such a declaration
9405    is erroneous, NULL_TREE is returned.
9406
9407    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9408    function, these are the qualifiers to give to the `this' pointer. We
9409    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9410
9411    May return void_type_node if the declarator turned out to be a friend.
9412    See grokfield for details.  */
9413
9414 tree
9415 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9416      tree declspecs;
9417      tree declarator;
9418      enum decl_context decl_context;
9419      int initialized;
9420      tree attrlist;
9421 {
9422   RID_BIT_TYPE specbits;
9423   int nclasses = 0;
9424   tree spec;
9425   tree type = NULL_TREE;
9426   int longlong = 0;
9427   int constp;
9428   int restrictp;
9429   int volatilep;
9430   int type_quals;
9431   int virtualp, explicitp, friendp, inlinep, staticp;
9432   int explicit_int = 0;
9433   int explicit_char = 0;
9434   int defaulted_int = 0;
9435   tree typedef_decl = NULL_TREE;
9436   const char *name;
9437   tree typedef_type = NULL_TREE;
9438   int funcdef_flag = 0;
9439   enum tree_code innermost_code = ERROR_MARK;
9440   int bitfield = 0;
9441 #if 0
9442   /* See the code below that used this.  */
9443   tree decl_machine_attr = NULL_TREE;
9444 #endif
9445   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9446      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9447   tree init = NULL_TREE;
9448
9449   /* Keep track of what sort of function is being processed
9450      so that we can warn about default return values, or explicit
9451      return values which do not match prescribed defaults.  */
9452   special_function_kind sfk = sfk_none;
9453
9454   tree dname = NULL_TREE;
9455   tree ctype = current_class_type;
9456   tree ctor_return_type = NULL_TREE;
9457   enum overload_flags flags = NO_SPECIAL;
9458   tree quals = NULL_TREE;
9459   tree raises = NULL_TREE;
9460   int template_count = 0;
9461   tree in_namespace = NULL_TREE;
9462   tree inner_attrs;
9463   int ignore_attrs;
9464
9465   RIDBIT_RESET_ALL (specbits);
9466   if (decl_context == FUNCDEF)
9467     funcdef_flag = 1, decl_context = NORMAL;
9468   else if (decl_context == MEMFUNCDEF)
9469     funcdef_flag = -1, decl_context = FIELD;
9470   else if (decl_context == BITFIELD)
9471     bitfield = 1, decl_context = FIELD;
9472
9473   /* Look inside a declarator for the name being declared
9474      and get it as a string, for an error message.  */
9475   {
9476     tree *next = &declarator;
9477     register tree decl;
9478     name = NULL;
9479
9480     while (next && *next)
9481       {
9482         decl = *next;
9483         switch (TREE_CODE (decl))
9484           {
9485           case TREE_LIST:
9486             /* For attributes.  */
9487             next = &TREE_VALUE (decl);
9488             break;
9489
9490           case COND_EXPR:
9491             ctype = NULL_TREE;
9492             next = &TREE_OPERAND (decl, 0);
9493             break;
9494
9495           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9496             {
9497               tree name = TREE_OPERAND (decl, 0);
9498               tree rename = NULL_TREE;
9499
9500               my_friendly_assert (flags == NO_SPECIAL, 152);
9501               flags = DTOR_FLAG;
9502               sfk = sfk_destructor;
9503               if (TREE_CODE (name) == TYPE_DECL)
9504                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9505               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9506               if (ctype == NULL_TREE)
9507                 {
9508                   if (current_class_type == NULL_TREE)
9509                     {
9510                       error ("destructors must be member functions");
9511                       flags = NO_SPECIAL;
9512                     }
9513                   else
9514                     {
9515                       tree t = constructor_name (current_class_name);
9516                       if (t != name)
9517                         rename = t;
9518                     }
9519                 }
9520               else
9521                 {
9522                   tree t = constructor_name (ctype);
9523                   if (t != name)
9524                     rename = t;
9525                 }
9526
9527               if (rename)
9528                 {
9529                   cp_error ("destructor `%T' must match class name `%T'",
9530                             name, rename);
9531                   TREE_OPERAND (decl, 0) = rename;
9532                 }
9533               next = &name;
9534             }
9535             break;
9536
9537           case ADDR_EXPR:       /* C++ reference declaration */
9538             /* Fall through. */
9539           case ARRAY_REF:
9540           case INDIRECT_REF:
9541             ctype = NULL_TREE;
9542             innermost_code = TREE_CODE (decl);
9543             next = &TREE_OPERAND (decl, 0);
9544             break;
9545
9546           case CALL_EXPR:
9547             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9548               {
9549                 /* This is actually a variable declaration using
9550                    constructor syntax.  We need to call start_decl and
9551                    cp_finish_decl so we can get the variable
9552                    initialized...  */
9553
9554                 tree attributes, prefix_attributes;
9555
9556                 *next = TREE_OPERAND (decl, 0);
9557                 init = CALL_DECLARATOR_PARMS (decl);
9558
9559                 if (attrlist)
9560                   {
9561                     attributes = TREE_PURPOSE (attrlist);
9562                     prefix_attributes = TREE_VALUE (attrlist);
9563                   }
9564                 else
9565                   {
9566                     attributes = NULL_TREE;
9567                     prefix_attributes = NULL_TREE;
9568                   }
9569
9570                 decl = start_decl (declarator, declspecs, 1,
9571                                    attributes, prefix_attributes);
9572                 decl_type_access_control (decl);
9573                 if (decl)
9574                   {
9575                     /* Look for __unused__ attribute */
9576                     if (TREE_USED (TREE_TYPE (decl)))
9577                       TREE_USED (decl) = 1;
9578                     finish_decl (decl, init, NULL_TREE);
9579                   }
9580                 else
9581                   cp_error ("invalid declarator");
9582                 return 0;
9583               }
9584             innermost_code = TREE_CODE (decl);
9585             if (decl_context == FIELD && ctype == NULL_TREE)
9586               ctype = current_class_type;
9587             if (ctype
9588                 && TREE_OPERAND (decl, 0)
9589                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9590                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9591                          == constructor_name_full (ctype))
9592                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9593                             == constructor_name (ctype)))))
9594               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9595             next = &TREE_OPERAND (decl, 0);
9596             decl = *next;
9597             if (ctype != NULL_TREE
9598                 && decl != NULL_TREE && flags != DTOR_FLAG
9599                 && decl == constructor_name (ctype))
9600               {
9601                 sfk = sfk_constructor;
9602                 ctor_return_type = ctype;
9603               }
9604             ctype = NULL_TREE;
9605             break;
9606
9607           case TEMPLATE_ID_EXPR:
9608               {
9609                 tree fns = TREE_OPERAND (decl, 0);
9610
9611                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9612                   fns = TREE_OPERAND (fns, 0);
9613
9614                 dname = fns;
9615                 if (TREE_CODE (dname) == COMPONENT_REF)
9616                   dname = TREE_OPERAND (dname, 1);
9617                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9618                   {
9619                     my_friendly_assert (is_overloaded_fn (dname),
9620                                         19990331);
9621                     dname = DECL_NAME (get_first_fn (dname));
9622                   }
9623               }
9624           /* Fall through. */
9625
9626           case IDENTIFIER_NODE:
9627             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9628               dname = decl;
9629
9630             next = 0;
9631
9632             if (is_rid (dname))
9633               {
9634                 cp_error ("declarator-id missing; using reserved word `%D'",
9635                           dname);
9636                 name = IDENTIFIER_POINTER (dname);
9637               }
9638             if (! IDENTIFIER_OPNAME_P (dname)
9639                 /* GNU/Linux headers use '__op'.  Arrgh.  */
9640                 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
9641               name = IDENTIFIER_POINTER (dname);
9642             else
9643               {
9644                 if (IDENTIFIER_TYPENAME_P (dname))
9645                   {
9646                     my_friendly_assert (flags == NO_SPECIAL, 154);
9647                     flags = TYPENAME_FLAG;
9648                     ctor_return_type = TREE_TYPE (dname);
9649                     sfk = sfk_conversion;
9650                   }
9651                 name = operator_name_string (dname);
9652               }
9653             break;
9654
9655             /* C++ extension */
9656           case SCOPE_REF:
9657             {
9658               /* Perform error checking, and decide on a ctype.  */
9659               tree cname = TREE_OPERAND (decl, 0);
9660               if (cname == NULL_TREE)
9661                 ctype = NULL_TREE;
9662               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9663                 {
9664                   ctype = NULL_TREE;
9665                   in_namespace = TREE_OPERAND (decl, 0);
9666                   TREE_OPERAND (decl, 0) = NULL_TREE;
9667                 }
9668               else if (! is_aggr_type (cname, 1))
9669                 TREE_OPERAND (decl, 0) = NULL_TREE;
9670               /* Must test TREE_OPERAND (decl, 1), in case user gives
9671                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9672               else if (TREE_OPERAND (decl, 1)
9673                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9674                 ctype = cname;
9675               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9676                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9677                 {
9678                   cp_error ("`%T::%D' is not a valid declarator", cname,
9679                             TREE_OPERAND (decl, 1));
9680                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9681                             cname, TREE_OPERAND (decl, 1));
9682                   return void_type_node;
9683                 }
9684               else if (ctype == NULL_TREE)
9685                 ctype = cname;
9686               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9687                 TREE_OPERAND (decl, 0) = ctype;
9688               else
9689                 {
9690                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9691                     {
9692                       cp_error ("type `%T' is not derived from type `%T'",
9693                                 cname, ctype);
9694                       TREE_OPERAND (decl, 0) = NULL_TREE;
9695                     }
9696                   else
9697                     ctype = cname;
9698                 }
9699
9700               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9701                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9702                        == constructor_name_full (ctype))
9703                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9704                           == constructor_name (ctype))))
9705                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9706               next = &TREE_OPERAND (decl, 1);
9707               decl = *next;
9708               if (ctype)
9709                 {
9710                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9711                       && constructor_name (ctype) == decl)
9712                     {
9713                       sfk = sfk_constructor;
9714                       ctor_return_type = ctype;
9715                     }
9716                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9717                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9718                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9719                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9720                     {
9721                       sfk = sfk_destructor;
9722                       ctor_return_type = ctype;
9723                       flags = DTOR_FLAG;
9724                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9725                       next = &TREE_OPERAND (decl, 0);
9726                     }
9727                 }
9728             }
9729             break;
9730
9731           case ERROR_MARK:
9732             next = 0;
9733             break;
9734
9735           case TYPE_DECL:
9736             /* Parse error puts this typespec where
9737                a declarator should go.  */
9738             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9739             if (TREE_TYPE (decl) == current_class_type)
9740               cp_error ("  perhaps you want `%T' for a constructor",
9741                         current_class_name);
9742             dname = DECL_NAME (decl);
9743             name = IDENTIFIER_POINTER (dname);
9744
9745             /* Avoid giving two errors for this.  */
9746             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9747
9748             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9749             *next = dname;
9750             next = 0;
9751             break;
9752
9753           default:
9754             cp_compiler_error ("`%D' as declarator", decl);
9755             return 0; /* We used to do a 155 abort here.  */
9756           }
9757       }
9758   }
9759
9760   /* A function definition's declarator must have the form of
9761      a function declarator.  */
9762
9763   if (funcdef_flag && innermost_code != CALL_EXPR)
9764     return 0;
9765
9766   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9767       && innermost_code != CALL_EXPR
9768       && ! (ctype && declspecs == NULL_TREE))
9769     {
9770       cp_error ("declaration of `%D' as non-function", dname);
9771       return void_type_node;
9772     }
9773
9774   /* Anything declared one level down from the top level
9775      must be one of the parameters of a function
9776      (because the body is at least two levels down).  */
9777
9778   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9779      by not allowing C++ class definitions to specify their parameters
9780      with xdecls (must be spec.d in the parmlist).
9781
9782      Since we now wait to push a class scope until we are sure that
9783      we are in a legitimate method context, we must set oldcname
9784      explicitly (since current_class_name is not yet alive).
9785
9786      We also want to avoid calling this a PARM if it is in a namespace.  */
9787
9788   if (decl_context == NORMAL && !toplevel_bindings_p ())
9789     {
9790       struct binding_level *b = current_binding_level;
9791       current_binding_level = b->level_chain;
9792       if (current_binding_level != 0 && toplevel_bindings_p ())
9793         decl_context = PARM;
9794       current_binding_level = b;
9795     }
9796
9797   if (name == NULL)
9798     name = decl_context == PARM ? "parameter" : "type name";
9799
9800   /* Look through the decl specs and record which ones appear.
9801      Some typespecs are defined as built-in typenames.
9802      Others, the ones that are modifiers of other types,
9803      are represented by bits in SPECBITS: set the bits for
9804      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9805
9806      If there is a typedef name or a type, store the type in TYPE.
9807      This includes builtin typedefs such as `int'.
9808
9809      Set EXPLICIT_INT if the type is `int' or `char' and did not
9810      come from a user typedef.
9811
9812      Set LONGLONG if `long' is mentioned twice.
9813
9814      For C++, constructors and destructors have their own fast treatment.  */
9815
9816   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9817     {
9818       register int i;
9819       register tree id;
9820
9821       /* Certain parse errors slip through.  For example,
9822          `int class;' is not caught by the parser. Try
9823          weakly to recover here.  */
9824       if (TREE_CODE (spec) != TREE_LIST)
9825         return 0;
9826
9827       id = TREE_VALUE (spec);
9828
9829       if (TREE_CODE (id) == IDENTIFIER_NODE)
9830         {
9831           if (id == ridpointers[(int) RID_INT]
9832               || id == ridpointers[(int) RID_CHAR]
9833               || id == ridpointers[(int) RID_BOOL]
9834               || id == ridpointers[(int) RID_WCHAR])
9835             {
9836               if (type)
9837                 {
9838                   if (id == ridpointers[(int) RID_BOOL])
9839                     error ("`bool' is now a keyword");
9840                   else
9841                     cp_error ("extraneous `%T' ignored", id);
9842                 }
9843               else
9844                 {
9845                   if (id == ridpointers[(int) RID_INT])
9846                     explicit_int = 1;
9847                   else if (id == ridpointers[(int) RID_CHAR])
9848                     explicit_char = 1;
9849                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9850                 }
9851               goto found;
9852             }
9853           /* C++ aggregate types.  */
9854           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9855             {
9856               if (type)
9857                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9858               else
9859                 type = IDENTIFIER_TYPE_VALUE (id);
9860               goto found;
9861             }
9862
9863           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9864             {
9865               if (ridpointers[i] == id)
9866                 {
9867                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9868                     {
9869                       if (pedantic && ! in_system_header && warn_long_long)
9870                         pedwarn ("ISO C++ does not support `long long'");
9871                       if (longlong)
9872                         error ("`long long long' is too long for GCC");
9873                       else
9874                         longlong = 1;
9875                     }
9876                   else if (RIDBIT_SETP (i, specbits))
9877                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9878                   RIDBIT_SET (i, specbits);
9879                   goto found;
9880                 }
9881             }
9882         }
9883       /* C++ aggregate types.  */
9884       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9885         {
9886           if (type)
9887             cp_error ("multiple declarations `%T' and `%T'", type,
9888                       TREE_TYPE (id));
9889           else
9890             {
9891               type = TREE_TYPE (id);
9892               TREE_VALUE (spec) = type;
9893             }
9894           goto found;
9895         }
9896       if (type)
9897         error ("two or more data types in declaration of `%s'", name);
9898       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9899         {
9900           register tree t = lookup_name (id, 1);
9901           if (!t || TREE_CODE (t) != TYPE_DECL)
9902             error ("`%s' fails to be a typedef or built in type",
9903                    IDENTIFIER_POINTER (id));
9904           else
9905             {
9906               type = TREE_TYPE (t);
9907 #if 0
9908               /* See the code below that used this.  */
9909               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9910 #endif
9911               typedef_decl = t;
9912             }
9913         }
9914       else if (id != error_mark_node)
9915         /* Can't change CLASS nodes into RECORD nodes here!  */
9916         type = id;
9917
9918     found: ;
9919     }
9920
9921   typedef_type = type;
9922
9923   /* No type at all: default to `int', and set DEFAULTED_INT
9924      because it was not a user-defined typedef.  */
9925
9926   if (type == NULL_TREE
9927       && (RIDBIT_SETP (RID_SIGNED, specbits)
9928           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9929           || RIDBIT_SETP (RID_LONG, specbits)
9930           || RIDBIT_SETP (RID_SHORT, specbits)))
9931     {
9932       /* These imply 'int'.  */
9933       type = integer_type_node;
9934       defaulted_int = 1;
9935     }
9936
9937   if (sfk != sfk_none)
9938     type = check_special_function_return_type (sfk, type,
9939                                                ctor_return_type,
9940                                                ctor_return_type);
9941   else if (type == NULL_TREE)
9942     {
9943       int is_main;
9944
9945       explicit_int = -1;
9946
9947           /* We handle `main' specially here, because 'main () { }' is so
9948              common.  With no options, it is allowed.  With -Wreturn-type,
9949              it is a warning.  It is only an error with -pedantic-errors.  */
9950       is_main = (funcdef_flag
9951                  && MAIN_NAME_P (dname)
9952                  && ctype == NULL_TREE
9953                  && in_namespace == NULL_TREE
9954                  && current_namespace == global_namespace);
9955
9956       if (in_system_header || flag_ms_extensions)
9957         /* Allow it, sigh.  */;
9958       else if (pedantic || ! is_main)
9959         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
9960                     name);
9961       else if (warn_return_type)
9962         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
9963                     name);
9964
9965       type = integer_type_node;
9966     }
9967
9968   ctype = NULL_TREE;
9969
9970   /* Now process the modifiers that were specified
9971      and check for invalid combinations.  */
9972
9973   /* Long double is a special combination.  */
9974
9975   if (RIDBIT_SETP (RID_LONG, specbits)
9976       && TYPE_MAIN_VARIANT (type) == double_type_node)
9977     {
9978       RIDBIT_RESET (RID_LONG, specbits);
9979       type = build_qualified_type (long_double_type_node,
9980                                    CP_TYPE_QUALS (type));
9981     }
9982
9983   /* Check all other uses of type modifiers.  */
9984
9985   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9986       || RIDBIT_SETP (RID_SIGNED, specbits)
9987       || RIDBIT_SETP (RID_LONG, specbits)
9988       || RIDBIT_SETP (RID_SHORT, specbits))
9989     {
9990       int ok = 0;
9991
9992       if (TREE_CODE (type) == REAL_TYPE)
9993         error ("short, signed or unsigned invalid for `%s'", name);
9994       else if (TREE_CODE (type) != INTEGER_TYPE)
9995         error ("long, short, signed or unsigned invalid for `%s'", name);
9996       else if (RIDBIT_SETP (RID_LONG, specbits)
9997                && RIDBIT_SETP (RID_SHORT, specbits))
9998         error ("long and short specified together for `%s'", name);
9999       else if ((RIDBIT_SETP (RID_LONG, specbits)
10000                 || RIDBIT_SETP (RID_SHORT, specbits))
10001                && explicit_char)
10002         error ("long or short specified with char for `%s'", name);
10003       else if ((RIDBIT_SETP (RID_LONG, specbits)
10004                 || RIDBIT_SETP (RID_SHORT, specbits))
10005                && TREE_CODE (type) == REAL_TYPE)
10006         error ("long or short specified with floating type for `%s'", name);
10007       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10008                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10009         error ("signed and unsigned given together for `%s'", name);
10010       else
10011         {
10012           ok = 1;
10013           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10014             {
10015               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10016                        name);
10017               if (flag_pedantic_errors)
10018                 ok = 0;
10019             }
10020         }
10021
10022       /* Discard the type modifiers if they are invalid.  */
10023       if (! ok)
10024         {
10025           RIDBIT_RESET (RID_UNSIGNED, specbits);
10026           RIDBIT_RESET (RID_SIGNED, specbits);
10027           RIDBIT_RESET (RID_LONG, specbits);
10028           RIDBIT_RESET (RID_SHORT, specbits);
10029           longlong = 0;
10030         }
10031     }
10032
10033   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10034       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10035     {
10036       error ("complex invalid for `%s'", name);
10037       RIDBIT_RESET (RID_COMPLEX, specbits);
10038     }
10039
10040   /* Decide whether an integer type is signed or not.
10041      Optionally treat bitfields as signed by default.  */
10042   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10043       /* [class.bit]
10044
10045          It is implementation-defined whether a plain (neither
10046          explicitly signed or unsigned) char, short, int, or long
10047          bit-field is signed or unsigned.
10048
10049          Naturally, we extend this to long long as well.  Note that
10050          this does not include wchar_t.  */
10051       || (bitfield && !flag_signed_bitfields
10052           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10053           /* A typedef for plain `int' without `signed' can be
10054              controlled just like plain `int', but a typedef for
10055              `signed int' cannot be so controlled.  */
10056           && !(typedef_decl
10057                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10058           && (TREE_CODE (type) == INTEGER_TYPE
10059               || TREE_CODE (type) == CHAR_TYPE)
10060           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10061     {
10062       if (longlong)
10063         type = long_long_unsigned_type_node;
10064       else if (RIDBIT_SETP (RID_LONG, specbits))
10065         type = long_unsigned_type_node;
10066       else if (RIDBIT_SETP (RID_SHORT, specbits))
10067         type = short_unsigned_type_node;
10068       else if (type == char_type_node)
10069         type = unsigned_char_type_node;
10070       else if (typedef_decl)
10071         type = unsigned_type (type);
10072       else
10073         type = unsigned_type_node;
10074     }
10075   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10076            && type == char_type_node)
10077     type = signed_char_type_node;
10078   else if (longlong)
10079     type = long_long_integer_type_node;
10080   else if (RIDBIT_SETP (RID_LONG, specbits))
10081     type = long_integer_type_node;
10082   else if (RIDBIT_SETP (RID_SHORT, specbits))
10083     type = short_integer_type_node;
10084
10085   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10086     {
10087       /* If we just have "complex", it is equivalent to
10088          "complex double", but if any modifiers at all are specified it is
10089          the complex form of TYPE.  E.g, "complex short" is
10090          "complex short int".  */
10091
10092       if (defaulted_int && ! longlong
10093           && ! (RIDBIT_SETP (RID_LONG, specbits)
10094                 || RIDBIT_SETP (RID_SHORT, specbits)
10095                 || RIDBIT_SETP (RID_SIGNED, specbits)
10096                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10097         type = complex_double_type_node;
10098       else if (type == integer_type_node)
10099         type = complex_integer_type_node;
10100       else if (type == float_type_node)
10101         type = complex_float_type_node;
10102       else if (type == double_type_node)
10103         type = complex_double_type_node;
10104       else if (type == long_double_type_node)
10105         type = complex_long_double_type_node;
10106       else
10107         type = build_complex_type (type);
10108     }
10109
10110   if (sfk == sfk_conversion
10111       && (RIDBIT_SETP (RID_CONST, specbits)
10112           || RIDBIT_SETP (RID_VOLATILE, specbits)
10113           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10114     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10115               ctor_return_type);
10116
10117   /* Set CONSTP if this declaration is `const', whether by
10118      explicit specification or via a typedef.
10119      Likewise for VOLATILEP.  */
10120
10121   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10122   restrictp =
10123     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10124   volatilep =
10125     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10126   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10127                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10128                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10129   type = cp_build_qualified_type (type, type_quals);
10130   staticp = 0;
10131   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10132   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10133   RIDBIT_RESET (RID_VIRTUAL, specbits);
10134   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10135   RIDBIT_RESET (RID_EXPLICIT, specbits);
10136
10137   if (RIDBIT_SETP (RID_STATIC, specbits))
10138     staticp = 1 + (decl_context == FIELD);
10139
10140   if (virtualp && staticp == 2)
10141     {
10142       cp_error ("member `%D' cannot be declared both virtual and static",
10143                 dname);
10144       staticp = 0;
10145     }
10146   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10147   RIDBIT_RESET (RID_FRIEND, specbits);
10148
10149   /* Warn if two storage classes are given. Default to `auto'.  */
10150
10151   if (RIDBIT_ANY_SET (specbits))
10152     {
10153       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10154       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10155       if (decl_context == PARM && nclasses > 0)
10156         error ("storage class specifiers invalid in parameter declarations");
10157       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10158         {
10159           if (decl_context == PARM)
10160             error ("typedef declaration invalid in parameter declaration");
10161           nclasses++;
10162         }
10163       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10164       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10165     }
10166
10167   /* Give error if `virtual' is used outside of class declaration.  */
10168   if (virtualp
10169       && (current_class_name == NULL_TREE || decl_context != FIELD))
10170     {
10171       error ("virtual outside class declaration");
10172       virtualp = 0;
10173     }
10174
10175   /* Static anonymous unions are dealt with here.  */
10176   if (staticp && decl_context == TYPENAME
10177       && TREE_CODE (declspecs) == TREE_LIST
10178       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10179     decl_context = FIELD;
10180
10181   /* Warn about storage classes that are invalid for certain
10182      kinds of declarations (parameters, typenames, etc.).  */
10183
10184   if (nclasses > 1)
10185     error ("multiple storage classes in declaration of `%s'", name);
10186   else if (decl_context != NORMAL && nclasses > 0)
10187     {
10188       if ((decl_context == PARM || decl_context == CATCHPARM)
10189           && (RIDBIT_SETP (RID_REGISTER, specbits)
10190               || RIDBIT_SETP (RID_AUTO, specbits)))
10191         ;
10192       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10193         ;
10194       else if (decl_context == FIELD
10195                /* C++ allows static class elements  */
10196                && RIDBIT_SETP (RID_STATIC, specbits))
10197         /* C++ also allows inlines and signed and unsigned elements,
10198            but in those cases we don't come in here.  */
10199         ;
10200       else
10201         {
10202           if (decl_context == FIELD)
10203             {
10204               tree tmp = NULL_TREE;
10205               register int op = 0;
10206
10207               if (declarator)
10208                 {
10209                   /* Avoid trying to get an operand off an identifier node.  */
10210                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10211                     tmp = declarator;
10212                   else
10213                     tmp = TREE_OPERAND (declarator, 0);
10214                   op = IDENTIFIER_OPNAME_P (tmp);
10215                 }
10216               error ("storage class specified for %s `%s'",
10217                      op ? "member operator" : "field",
10218                      op ? operator_name_string (tmp) : name);
10219             }
10220           else
10221             {
10222               if (decl_context == PARM || decl_context == CATCHPARM)
10223                 error ("storage class specified for parameter `%s'", name);
10224               else
10225                 error ("storage class specified for typename");
10226             }
10227           RIDBIT_RESET (RID_REGISTER, specbits);
10228           RIDBIT_RESET (RID_AUTO, specbits);
10229           RIDBIT_RESET (RID_EXTERN, specbits);
10230         }
10231     }
10232   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10233     {
10234       if (toplevel_bindings_p ())
10235         {
10236           /* It's common practice (and completely valid) to have a const
10237              be initialized and declared extern.  */
10238           if (!(type_quals & TYPE_QUAL_CONST))
10239             warning ("`%s' initialized and declared `extern'", name);
10240         }
10241       else
10242         error ("`%s' has both `extern' and initializer", name);
10243     }
10244   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10245            && ! toplevel_bindings_p ())
10246     error ("nested function `%s' declared `extern'", name);
10247   else if (toplevel_bindings_p ())
10248     {
10249       if (RIDBIT_SETP (RID_AUTO, specbits))
10250         error ("top-level declaration of `%s' specifies `auto'", name);
10251     }
10252
10253   if (nclasses > 0 && friendp)
10254     error ("storage class specifiers invalid in friend function declarations");
10255
10256   /* Now figure out the structure of the declarator proper.
10257      Descend through it, creating more complex types, until we reach
10258      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10259
10260   inner_attrs = NULL_TREE;
10261   ignore_attrs = 0;
10262
10263   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10264          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10265     {
10266       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10267          an INDIRECT_REF (for *...),
10268          a CALL_EXPR (for ...(...)),
10269          an identifier (for the name being declared)
10270          or a null pointer (for the place in an absolute declarator
10271          where the name was omitted).
10272          For the last two cases, we have just exited the loop.
10273
10274          For C++ it could also be
10275          a SCOPE_REF (for class :: ...).  In this case, we have converted
10276          sensible names to types, and those are the values we use to
10277          qualify the member name.
10278          an ADDR_EXPR (for &...),
10279          a BIT_NOT_EXPR (for destructors)
10280
10281          At this point, TYPE is the type of elements of an array,
10282          or for a function to return, or for a pointer to point to.
10283          After this sequence of ifs, TYPE is the type of the
10284          array or function or pointer, and DECLARATOR has had its
10285          outermost layer removed.  */
10286
10287       if (type == error_mark_node)
10288         {
10289           if (TREE_CODE (declarator) == SCOPE_REF)
10290             declarator = TREE_OPERAND (declarator, 1);
10291           else
10292             declarator = TREE_OPERAND (declarator, 0);
10293           continue;
10294         }
10295       if (quals != NULL_TREE
10296           && (declarator == NULL_TREE
10297               || TREE_CODE (declarator) != SCOPE_REF))
10298         {
10299           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10300             ctype = TYPE_METHOD_BASETYPE (type);
10301           if (ctype != NULL_TREE)
10302             {
10303               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10304               grok_method_quals (ctype, dummy, quals);
10305               type = TREE_TYPE (dummy);
10306               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10307               quals = NULL_TREE;
10308             }
10309         }
10310
10311       /* See the comment for the TREE_LIST case, below.  */
10312       if (ignore_attrs)
10313         ignore_attrs = 0;
10314       else if (inner_attrs)
10315         {
10316           decl_attributes (type, inner_attrs, NULL_TREE);
10317           inner_attrs = NULL_TREE;
10318         }
10319
10320       switch (TREE_CODE (declarator))
10321         {
10322         case TREE_LIST:
10323           {
10324             /* We encode a declarator with embedded attributes using
10325                a TREE_LIST.  The attributes apply to the declarator
10326                directly inside them, so we have to skip an iteration
10327                before applying them to the type.  If the declarator just
10328                inside is the declarator-id, we apply the attrs to the
10329                decl itself.  */
10330             inner_attrs = TREE_PURPOSE (declarator);
10331             ignore_attrs = 1;
10332             declarator = TREE_VALUE (declarator);
10333           }
10334           break;
10335
10336         case ARRAY_REF:
10337           {
10338             register tree size;
10339
10340             size = TREE_OPERAND (declarator, 1);
10341
10342             /* VC++ spells a zero-sized array with [].  */
10343             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10344                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10345               size = integer_zero_node;
10346
10347             declarator = TREE_OPERAND (declarator, 0);
10348
10349             type = create_array_type_for_decl (dname, type, size);
10350             ctype = NULL_TREE;
10351           }
10352           break;
10353
10354         case CALL_EXPR:
10355           {
10356             tree arg_types;
10357             int funcdecl_p;
10358             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10359             tree inner_decl = TREE_OPERAND (declarator, 0);
10360
10361             /* Declaring a function type.
10362                Make sure we have a valid type for the function to return.  */
10363
10364             /* We now know that the TYPE_QUALS don't apply to the
10365                decl, but to its return type.  */
10366             type_quals = TYPE_UNQUALIFIED;
10367
10368             /* Warn about some types functions can't return.  */
10369
10370             if (TREE_CODE (type) == FUNCTION_TYPE)
10371               {
10372                 error ("`%s' declared as function returning a function", name);
10373                 type = integer_type_node;
10374               }
10375             if (TREE_CODE (type) == ARRAY_TYPE)
10376               {
10377                 error ("`%s' declared as function returning an array", name);
10378                 type = integer_type_node;
10379               }
10380
10381             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10382               inner_decl = TREE_OPERAND (inner_decl, 1);
10383
10384             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10385               inner_decl = dname;
10386
10387             /* Pick up type qualifiers which should be applied to `this'.  */
10388             quals = CALL_DECLARATOR_QUALS (declarator);
10389
10390             /* Pick up the exception specifications.  */
10391             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10392
10393             /* Say it's a definition only for the CALL_EXPR
10394                closest to the identifier.  */
10395             funcdecl_p
10396               = inner_decl
10397               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10398                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10399                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10400
10401             if (ctype == NULL_TREE
10402                 && decl_context == FIELD
10403                 && funcdecl_p
10404                 && (friendp == 0 || dname == current_class_name))
10405               ctype = current_class_type;
10406
10407             if (ctype && sfk == sfk_conversion)
10408               TYPE_HAS_CONVERSION (ctype) = 1;
10409             if (ctype && constructor_name (ctype) == dname)
10410               {
10411                 /* We are within a class's scope. If our declarator name
10412                    is the same as the class name, and we are defining
10413                    a function, then it is a constructor/destructor, and
10414                    therefore returns a void type.  */
10415
10416                 if (flags == DTOR_FLAG)
10417                   {
10418                     /* ISO C++ 12.4/2.  A destructor may not be
10419                        declared const or volatile.  A destructor may
10420                        not be static.  */
10421                     if (staticp == 2)
10422                       error ("destructor cannot be static member function");
10423                     if (quals)
10424                       {
10425                         cp_error ("destructors may not be `%s'",
10426                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10427                         quals = NULL_TREE;
10428                       }
10429                     if (decl_context == FIELD)
10430                       {
10431                         if (! member_function_or_else (ctype,
10432                                                        current_class_type,
10433                                                        flags))
10434                           return void_type_node;
10435                       }
10436                   }
10437                 else            /* It's a constructor.  */
10438                   {
10439                     if (explicitp == 1)
10440                       explicitp = 2;
10441                     /* ISO C++ 12.1.  A constructor may not be
10442                        declared const or volatile.  A constructor may
10443                        not be virtual.  A constructor may not be
10444                        static.  */
10445                     if (staticp == 2)
10446                       error ("constructor cannot be static member function");
10447                     if (virtualp)
10448                       {
10449                         pedwarn ("constructors cannot be declared virtual");
10450                         virtualp = 0;
10451                       }
10452                     if (quals)
10453                       {
10454                         cp_error ("constructors may not be `%s'",
10455                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10456                         quals = NULL_TREE;
10457                       }
10458                     {
10459                       RID_BIT_TYPE tmp_bits;
10460                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10461                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10462                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10463                       if (RIDBIT_ANY_SET (tmp_bits))
10464                         error ("return value type specifier for constructor ignored");
10465                     }
10466                     if (decl_context == FIELD)
10467                       {
10468                         if (! member_function_or_else (ctype,
10469                                                        current_class_type,
10470                                                        flags))
10471                           return void_type_node;
10472                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10473                         if (sfk != sfk_constructor)
10474                           return NULL_TREE;
10475                       }
10476                   }
10477                 if (decl_context == FIELD)
10478                   staticp = 0;
10479               }
10480             else if (friendp)
10481               {
10482                 if (initialized)
10483                   error ("can't initialize friend function `%s'", name);
10484                 if (virtualp)
10485                   {
10486                     /* Cannot be both friend and virtual.  */
10487                     error ("virtual functions cannot be friends");
10488                     RIDBIT_RESET (RID_FRIEND, specbits);
10489                     friendp = 0;
10490                   }
10491                 if (decl_context == NORMAL)
10492                   error ("friend declaration not in class definition");
10493                 if (current_function_decl && funcdef_flag)
10494                   cp_error ("can't define friend function `%s' in a local class definition",
10495                             name);
10496               }
10497
10498             /* Construct the function type and go to the next
10499                inner layer of declarator.  */
10500
10501             declarator = TREE_OPERAND (declarator, 0);
10502
10503             /* FIXME: This is where default args should be fully
10504                processed.  */
10505
10506             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10507
10508             if (declarator && flags == DTOR_FLAG)
10509               {
10510                 /* A destructor declared in the body of a class will
10511                    be represented as a BIT_NOT_EXPR.  But, we just
10512                    want the underlying IDENTIFIER.  */
10513                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10514                   declarator = TREE_OPERAND (declarator, 0);
10515
10516                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10517                   arg_types = void_list_node;
10518                 else if (arg_types == NULL_TREE
10519                          || arg_types != void_list_node)
10520                   {
10521                     cp_error ("destructors may not have parameters");
10522                     arg_types = void_list_node;
10523                     last_function_parms = NULL_TREE;
10524                   }
10525               }
10526
10527             /* ANSI says that `const int foo ();'
10528                does not make the function foo const.  */
10529             type = build_function_type (type, arg_types);
10530
10531             {
10532               tree t;
10533               for (t = arg_types; t; t = TREE_CHAIN (t))
10534                 if (TREE_PURPOSE (t)
10535                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10536                   {
10537                     add_defarg_fn (type);
10538                     break;
10539                   }
10540             }
10541           }
10542           break;
10543
10544         case ADDR_EXPR:
10545         case INDIRECT_REF:
10546           /* Filter out pointers-to-references and references-to-references.
10547              We can get these if a TYPE_DECL is used.  */
10548
10549           if (TREE_CODE (type) == REFERENCE_TYPE)
10550             {
10551               error ("cannot declare %s to references",
10552                      TREE_CODE (declarator) == ADDR_EXPR
10553                      ? "references" : "pointers");
10554               declarator = TREE_OPERAND (declarator, 0);
10555               continue;
10556             }
10557
10558           if (TREE_CODE (type) == OFFSET_TYPE
10559               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10560                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10561             {
10562               cp_error ("cannot declare pointer to `%#T' member",
10563                         TREE_TYPE (type));
10564               type = TREE_TYPE (type);
10565             }
10566
10567           /* Merge any constancy or volatility into the target type
10568              for the pointer.  */
10569
10570           /* We now know that the TYPE_QUALS don't apply to the decl,
10571              but to the target of the pointer.  */
10572           type_quals = TYPE_UNQUALIFIED;
10573
10574           if (TREE_CODE (declarator) == ADDR_EXPR)
10575             {
10576               if (TREE_CODE (type) == VOID_TYPE)
10577                 error ("invalid type: `void &'");
10578               else
10579                 type = build_reference_type (type);
10580             }
10581           else if (TREE_CODE (type) == METHOD_TYPE)
10582             type = build_ptrmemfunc_type (build_pointer_type (type));
10583           else
10584             type = build_pointer_type (type);
10585
10586           /* Process a list of type modifier keywords (such as
10587              const or volatile) that were given inside the `*' or `&'.  */
10588
10589           if (TREE_TYPE (declarator))
10590             {
10591               register tree typemodlist;
10592               int erred = 0;
10593
10594               constp = 0;
10595               volatilep = 0;
10596               restrictp = 0;
10597               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10598                    typemodlist = TREE_CHAIN (typemodlist))
10599                 {
10600                   tree qualifier = TREE_VALUE (typemodlist);
10601
10602                   if (qualifier == ridpointers[(int) RID_CONST])
10603                     constp++;
10604                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10605                     volatilep++;
10606                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10607                     restrictp++;
10608                   else if (!erred)
10609                     {
10610                       erred = 1;
10611                       error ("invalid type modifier within pointer declarator");
10612                     }
10613                 }
10614               if (constp > 1)
10615                 pedwarn ("duplicate `const'");
10616               if (volatilep > 1)
10617                 pedwarn ("duplicate `volatile'");
10618               if (restrictp > 1)
10619                 pedwarn ("duplicate `restrict'");
10620
10621               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10622                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10623                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10624               if (TREE_CODE (declarator) == ADDR_EXPR
10625                   && (constp || volatilep))
10626                 {
10627                   if (constp)
10628                     pedwarn ("discarding `const' applied to a reference");
10629                   if (volatilep)
10630                     pedwarn ("discarding `volatile' applied to a reference");
10631                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10632                 }
10633               type = cp_build_qualified_type (type, type_quals);
10634             }
10635           declarator = TREE_OPERAND (declarator, 0);
10636           ctype = NULL_TREE;
10637           break;
10638
10639         case SCOPE_REF:
10640           {
10641             /* We have converted type names to NULL_TREE if the
10642                name was bogus, or to a _TYPE node, if not.
10643
10644                The variable CTYPE holds the type we will ultimately
10645                resolve to.  The code here just needs to build
10646                up appropriate member types.  */
10647             tree sname = TREE_OPERAND (declarator, 1);
10648             tree t;
10649
10650             /* Destructors can have their visibilities changed as well.  */
10651             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10652               sname = TREE_OPERAND (sname, 0);
10653
10654             if (TREE_COMPLEXITY (declarator) == 0)
10655               /* This needs to be here, in case we are called
10656                  multiple times.  */ ;
10657             else if (TREE_COMPLEXITY (declarator) == -1)
10658               /* Namespace member. */
10659               pop_decl_namespace ();
10660             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10661               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10662             else if (! IS_AGGR_TYPE_CODE
10663                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10664               ;
10665             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10666               {
10667                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10668                    that refer to ctype.  They couldn't be resolved earlier
10669                    because we hadn't pushed into the class yet.
10670                    Example: resolve 'B<T>::type' in
10671                    'B<typename B<T>::type> B<T>::f () { }'.  */
10672                 if (current_template_parms
10673                     && uses_template_parms (type)
10674                     && uses_template_parms (current_class_type))
10675                   {
10676                     tree args = current_template_args ();
10677                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10678                   }
10679
10680                 /* This pop_nested_class corresponds to the
10681                    push_nested_class used to push into class scope for
10682                    parsing the argument list of a function decl, in
10683                    qualified_id.  */
10684                 pop_nested_class ();
10685                 TREE_COMPLEXITY (declarator) = current_class_depth;
10686               }
10687             else
10688               my_friendly_abort (16);
10689
10690             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10691               {
10692                 /* We had a reference to a global decl, or
10693                    perhaps we were given a non-aggregate typedef,
10694                    in which case we cleared this out, and should just
10695                    keep going as though it wasn't there.  */
10696                 declarator = sname;
10697                 continue;
10698               }
10699             ctype = TREE_OPERAND (declarator, 0);
10700
10701             t = ctype;
10702             while (t != NULL_TREE && CLASS_TYPE_P (t))
10703               {
10704                 /* You're supposed to have one `template <...>'
10705                    for every template class, but you don't need one
10706                    for a full specialization.  For example:
10707
10708                      template <class T> struct S{};
10709                      template <> struct S<int> { void f(); };
10710                      void S<int>::f () {}
10711
10712                    is correct; there shouldn't be a `template <>' for
10713                    the definition of `S<int>::f'.  */
10714                 if (CLASSTYPE_TEMPLATE_INFO (t)
10715                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10716                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10717                   template_count += 1;
10718
10719                 t = TYPE_MAIN_DECL (t);
10720                 if (DECL_LANG_SPECIFIC (t))
10721                   t = DECL_CONTEXT (t);
10722                 else
10723                   t = NULL_TREE;
10724               }
10725
10726             if (sname == NULL_TREE)
10727               goto done_scoping;
10728
10729             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10730               {
10731                 /* This is the `standard' use of the scoping operator:
10732                    basetype :: member .  */
10733
10734                 if (ctype == current_class_type)
10735                   {
10736                     /* class A {
10737                          void A::f ();
10738                        };
10739
10740                        Is this ill-formed?  */
10741
10742                     if (pedantic)
10743                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10744                                   ctype, name);
10745                   }
10746                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10747                   {
10748                     if (current_class_type == NULL_TREE
10749                         || friendp)
10750                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10751                                                       TYPE_ARG_TYPES (type));
10752                     else
10753                       {
10754                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10755                                   ctype, name, current_class_type);
10756                         return void_type_node;
10757                       }
10758                   }
10759                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10760                          || COMPLETE_TYPE_P (complete_type (ctype)))
10761                   {
10762                     /* Have to move this code elsewhere in this function.
10763                        this code is used for i.e., typedef int A::M; M *pm;
10764
10765                        It is?  How? jason 10/2/94 */
10766
10767                     if (current_class_type)
10768                       {
10769                         cp_error ("cannot declare member `%T::%s' within `%T'",
10770                                   ctype, name, current_class_type);
10771                         return void_type_node;
10772                       }
10773                     type = build_offset_type (ctype, type);
10774                   }
10775                 else if (uses_template_parms (ctype))
10776                   {
10777                     if (TREE_CODE (type) == FUNCTION_TYPE)
10778                       type
10779                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10780                                                    TYPE_ARG_TYPES (type));
10781                   }
10782                 else
10783                   {
10784                     cp_error ("structure `%T' not yet defined", ctype);
10785                     return error_mark_node;
10786                   }
10787
10788                 declarator = sname;
10789               }
10790             else if (TREE_CODE (sname) == SCOPE_REF)
10791               my_friendly_abort (17);
10792             else
10793               {
10794               done_scoping:
10795                 declarator = TREE_OPERAND (declarator, 1);
10796                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10797                   /* In this case, we will deal with it later.  */
10798                   ;
10799                 else
10800                   {
10801                     if (TREE_CODE (type) == FUNCTION_TYPE)
10802                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10803                                                       TYPE_ARG_TYPES (type));
10804                     else
10805                       type = build_offset_type (ctype, type);
10806                   }
10807               }
10808           }
10809           break;
10810
10811         case BIT_NOT_EXPR:
10812           declarator = TREE_OPERAND (declarator, 0);
10813           break;
10814
10815         case RECORD_TYPE:
10816         case UNION_TYPE:
10817         case ENUMERAL_TYPE:
10818           declarator = NULL_TREE;
10819           break;
10820
10821         case ERROR_MARK:
10822           declarator = NULL_TREE;
10823           break;
10824
10825         default:
10826           my_friendly_abort (158);
10827         }
10828     }
10829
10830   /* See the comment for the TREE_LIST case, above.  */
10831   if (inner_attrs)
10832     {
10833       if (! ignore_attrs)
10834         decl_attributes (type, inner_attrs, NULL_TREE);
10835       else if (attrlist)
10836         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10837       else
10838         attrlist = build_decl_list (NULL_TREE, inner_attrs);
10839     }
10840
10841   /* Now TYPE has the actual type.  */
10842
10843   if (explicitp == 1 || (explicitp && friendp))
10844     {
10845       /* [dcl.fct.spec] The explicit specifier shall only be used in
10846          declarations of constructors within a class definition.  */
10847       error ("only declarations of constructors can be `explicit'");
10848       explicitp = 0;
10849     }
10850
10851   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10852     {
10853       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10854         {
10855           error ("non-member `%s' cannot be declared `mutable'", name);
10856           RIDBIT_RESET (RID_MUTABLE, specbits);
10857         }
10858       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10859         {
10860           error ("non-object member `%s' cannot be declared `mutable'", name);
10861           RIDBIT_RESET (RID_MUTABLE, specbits);
10862         }
10863       else if (TREE_CODE (type) == FUNCTION_TYPE
10864                || TREE_CODE (type) == METHOD_TYPE)
10865         {
10866           error ("function `%s' cannot be declared `mutable'", name);
10867           RIDBIT_RESET (RID_MUTABLE, specbits);
10868         }
10869       else if (staticp)
10870         {
10871           error ("static `%s' cannot be declared `mutable'", name);
10872           RIDBIT_RESET (RID_MUTABLE, specbits);
10873         }
10874       else if (type_quals & TYPE_QUAL_CONST)
10875         {
10876           error ("const `%s' cannot be declared `mutable'", name);
10877           RIDBIT_RESET (RID_MUTABLE, specbits);
10878         }
10879     }
10880
10881   if (declarator == NULL_TREE
10882       || TREE_CODE (declarator) == IDENTIFIER_NODE
10883       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10884           && (TREE_CODE (type) == FUNCTION_TYPE
10885               || TREE_CODE (type) == METHOD_TYPE)))
10886     /* OK */;
10887   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10888     {
10889       cp_error ("template-id `%D' used as a declarator", declarator);
10890       declarator = dname;
10891     }
10892   else
10893     /* Unexpected declarator format.  */
10894     my_friendly_abort (990210);
10895
10896   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10897
10898   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10899     {
10900       tree decl;
10901
10902       /* Note that the grammar rejects storage classes
10903          in typenames, fields or parameters.  */
10904       if (current_lang_name == lang_name_java)
10905         TYPE_FOR_JAVA (type) = 1;
10906
10907       if (decl_context == FIELD)
10908         {
10909           if (declarator == constructor_name (current_class_type))
10910             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10911                         declarator);
10912           decl = build_lang_decl (TYPE_DECL, declarator, type);
10913         }
10914       else
10915         {
10916           /* Make sure this typedef lives as long as its type,
10917              since it might be used as a template parameter. */
10918           if (processing_template_decl)
10919             decl = build_lang_decl (TYPE_DECL, declarator, type);
10920           else
10921             decl = build_decl (TYPE_DECL, declarator, type);
10922         }
10923
10924       /* If the user declares "typedef struct {...} foo" then the
10925          struct will have an anonymous name.  Fill that name in now.
10926          Nothing can refer to it, so nothing needs know about the name
10927          change.  */
10928       if (type != error_mark_node
10929           && declarator
10930           && TYPE_NAME (type)
10931           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10932           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10933           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10934         {
10935           tree oldname = TYPE_NAME (type);
10936           tree t;
10937
10938           /* Replace the anonymous name with the real name everywhere.  */
10939           lookup_tag_reverse (type, declarator);
10940           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10941             if (TYPE_NAME (t) == oldname)
10942               TYPE_NAME (t) = decl;
10943
10944           if (TYPE_LANG_SPECIFIC (type))
10945             TYPE_WAS_ANONYMOUS (type) = 1;
10946
10947           /* If this is a typedef within a template class, the nested
10948              type is a (non-primary) template.  The name for the
10949              template needs updating as well.  */
10950           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10951             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10952               = TYPE_IDENTIFIER (type);
10953
10954           /* XXX Temporarily set the scope.
10955              When returning, start_decl expects it as NULL_TREE,
10956              and will then then set it using pushdecl. */
10957           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10958           if (current_class_type)
10959             DECL_CONTEXT (decl) = current_class_type;
10960           else
10961             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10962
10963           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10964           DECL_ASSEMBLER_NAME (decl)
10965             = get_identifier (build_overload_name (type, 1, 1));
10966           DECL_CONTEXT (decl) = NULL_TREE;
10967
10968           /* FIXME remangle member functions; member functions of a
10969              type with external linkage have external linkage.  */
10970         }
10971
10972       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10973         {
10974           cp_error_at ("typedef name may not be class-qualified", decl);
10975           return NULL_TREE;
10976         }
10977       else if (quals)
10978         {
10979           if (ctype == NULL_TREE)
10980             {
10981               if (TREE_CODE (type) != METHOD_TYPE)
10982                 cp_error_at ("invalid type qualifier for non-member function type", decl);
10983               else
10984                 ctype = TYPE_METHOD_BASETYPE (type);
10985             }
10986           if (ctype != NULL_TREE)
10987             grok_method_quals (ctype, decl, quals);
10988         }
10989
10990       if (RIDBIT_SETP (RID_SIGNED, specbits)
10991           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10992         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10993
10994       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
10995                       inlinep, friendp, raises != NULL_TREE);
10996
10997       if (initialized)
10998         error ("typedef declaration includes an initializer");
10999
11000       return decl;
11001     }
11002
11003   /* Detect the case of an array type of unspecified size
11004      which came, as such, direct from a typedef name.
11005      We must copy the type, so that each identifier gets
11006      a distinct type, so that each identifier's size can be
11007      controlled separately by its own initializer.  */
11008
11009   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11010       && TYPE_DOMAIN (type) == NULL_TREE)
11011     {
11012       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11013     }
11014
11015   /* If this is a type name (such as, in a cast or sizeof),
11016      compute the type and return it now.  */
11017
11018   if (decl_context == TYPENAME)
11019     {
11020       /* Note that the grammar rejects storage classes
11021          in typenames, fields or parameters.  */
11022       if (type_quals != TYPE_UNQUALIFIED)
11023         type_quals = TYPE_UNQUALIFIED;
11024
11025       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11026       if (friendp)
11027         {
11028           if (type_quals != TYPE_UNQUALIFIED)
11029             {
11030               cp_error ("type qualifiers specified for friend class declaration");
11031               type_quals = TYPE_UNQUALIFIED;
11032             }
11033           if (inlinep)
11034             {
11035               cp_error ("`inline' specified for friend class declaration");
11036               inlinep = 0;
11037             }
11038
11039           /* Only try to do this stuff if we didn't already give up.  */
11040           if (type != integer_type_node)
11041             {
11042               /* A friendly class?  */
11043               if (current_class_type)
11044                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11045               else
11046                 error ("trying to make class `%s' a friend of global scope",
11047                        TYPE_NAME_STRING (type));
11048               type = void_type_node;
11049             }
11050         }
11051       else if (quals)
11052         {
11053           if (ctype == NULL_TREE)
11054             {
11055               if (TREE_CODE (type) != METHOD_TYPE)
11056                 cp_error ("invalid qualifiers on non-member function type");
11057               else
11058                 ctype = TYPE_METHOD_BASETYPE (type);
11059             }
11060           if (ctype)
11061             {
11062               tree dummy = build_decl (TYPE_DECL, declarator, type);
11063               grok_method_quals (ctype, dummy, quals);
11064               type = TREE_TYPE (dummy);
11065             }
11066         }
11067
11068       return type;
11069     }
11070   else if (declarator == NULL_TREE && decl_context != PARM
11071            && decl_context != CATCHPARM
11072            && TREE_CODE (type) != UNION_TYPE
11073            && ! bitfield)
11074     {
11075       cp_error ("abstract declarator `%T' used as declaration", type);
11076       declarator = make_anon_name ();
11077     }
11078
11079   /* `void' at top level (not within pointer)
11080      is allowed only in typedefs or type names.
11081      We don't complain about parms either, but that is because
11082      a better error message can be made later.  */
11083
11084   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11085     {
11086       if (! declarator)
11087         error ("unnamed variable or field declared void");
11088       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11089         {
11090           if (IDENTIFIER_OPNAME_P (declarator))
11091             my_friendly_abort (356);
11092           else
11093             error ("variable or field `%s' declared void", name);
11094         }
11095       else
11096         error ("variable or field declared void");
11097       type = integer_type_node;
11098     }
11099
11100   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11101      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11102
11103   if (decl_context == PARM || decl_context == CATCHPARM)
11104     {
11105       if (ctype || in_namespace)
11106         error ("cannot use `::' in parameter declaration");
11107
11108       /* A parameter declared as an array of T is really a pointer to T.
11109          One declared as a function is really a pointer to a function.
11110          One declared as a member is really a pointer to member.  */
11111
11112       if (TREE_CODE (type) == ARRAY_TYPE)
11113         {
11114           /* Transfer const-ness of array into that of type pointed to.  */
11115           type = build_pointer_type (TREE_TYPE (type));
11116           type_quals = TYPE_UNQUALIFIED;
11117         }
11118       else if (TREE_CODE (type) == FUNCTION_TYPE)
11119         type = build_pointer_type (type);
11120       else if (TREE_CODE (type) == OFFSET_TYPE)
11121         type = build_pointer_type (type);
11122       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11123         {
11124           error ("declaration of `%s' as void", name);
11125           return NULL_TREE;
11126         }
11127     }
11128
11129   {
11130     register tree decl;
11131
11132     if (decl_context == PARM)
11133       {
11134         decl = build_decl (PARM_DECL, declarator, type);
11135
11136         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11137                         inlinep, friendp, raises != NULL_TREE);
11138
11139         /* Compute the type actually passed in the parmlist,
11140            for the case where there is no prototype.
11141            (For example, shorts and chars are passed as ints.)
11142            When there is a prototype, this is overridden later.  */
11143
11144         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11145       }
11146     else if (decl_context == FIELD)
11147       {
11148         if (type == error_mark_node)
11149           {
11150             /* Happens when declaring arrays of sizes which
11151                are error_mark_node, for example.  */
11152             decl = NULL_TREE;
11153           }
11154         else if (in_namespace && !friendp)
11155           {
11156             /* Something like struct S { int N::j; };  */
11157             cp_error ("invalid use of `::'");
11158             decl = NULL_TREE;
11159           }
11160         else if (TREE_CODE (type) == FUNCTION_TYPE)
11161           {
11162             int publicp = 0;
11163             tree function_context;
11164
11165             /* We catch the others as conflicts with the builtin
11166                typedefs.  */
11167             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11168               {
11169                 cp_error ("function `%D' cannot be declared friend",
11170                           declarator);
11171                 friendp = 0;
11172               }
11173
11174             if (friendp == 0)
11175               {
11176                 if (ctype == NULL_TREE)
11177                   ctype = current_class_type;
11178
11179                 if (ctype == NULL_TREE)
11180                   {
11181                     cp_error ("can't make `%D' into a method -- not in a class",
11182                               declarator);
11183                     return void_type_node;
11184                   }
11185
11186                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11187                    ARM 9.5 */
11188                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11189                   {
11190                     cp_error ("function `%D' declared virtual inside a union",
11191                               declarator);
11192                     return void_type_node;
11193                   }
11194
11195                 if (declarator == ansi_opname[(int) NEW_EXPR]
11196                     || declarator == ansi_opname[(int) VEC_NEW_EXPR]
11197                     || declarator == ansi_opname[(int) DELETE_EXPR]
11198                     || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
11199                   {
11200                     if (virtualp)
11201                       {
11202                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11203                                   declarator);
11204                         virtualp = 0;
11205                       }
11206                   }
11207                 else if (staticp < 2)
11208                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11209                                                   TYPE_ARG_TYPES (type));
11210               }
11211
11212             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11213             function_context = (ctype != NULL_TREE) ?
11214               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11215             publicp = (! friendp || ! staticp)
11216               && function_context == NULL_TREE;
11217             decl = grokfndecl (ctype, type,
11218                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11219                                ? declarator : dname,
11220                                declarator,
11221                                virtualp, flags, quals, raises,
11222                                friendp ? -1 : 0, friendp, publicp, inlinep,
11223                                funcdef_flag, template_count, in_namespace);
11224             if (decl == NULL_TREE)
11225               return decl;
11226 #if 0
11227             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11228             /* The decl and setting of decl_machine_attr is also turned off.  */
11229             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11230 #endif
11231
11232             /* [class.conv.ctor]
11233
11234                A constructor declared without the function-specifier
11235                explicit that can be called with a single parameter
11236                specifies a conversion from the type of its first
11237                parameter to the type of its class.  Such a constructor
11238                is called a converting constructor.  */
11239             if (explicitp == 2)
11240               DECL_NONCONVERTING_P (decl) = 1;
11241             else if (DECL_CONSTRUCTOR_P (decl))
11242               {
11243                 /* The constructor can be called with exactly one
11244                    parameter if there is at least one parameter, and
11245                    any subsequent parameters have default arguments.
11246                    We don't look at the first parameter, which is
11247                    really just the `this' parameter for the new
11248                    object.  */
11249                 tree arg_types =
11250                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11251
11252                 /* Skip the `in_chrg' argument too, if present.  */
11253                 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl)))
11254                   arg_types = TREE_CHAIN (arg_types);
11255
11256                 if (arg_types == void_list_node
11257                     || (arg_types
11258                         && TREE_CHAIN (arg_types)
11259                         && TREE_CHAIN (arg_types) != void_list_node
11260                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11261                   DECL_NONCONVERTING_P (decl) = 1;
11262               }
11263           }
11264         else if (TREE_CODE (type) == METHOD_TYPE)
11265           {
11266             /* We only get here for friend declarations of
11267                members of other classes.  */
11268             /* All method decls are public, so tell grokfndecl to set
11269                TREE_PUBLIC, also.  */
11270             decl = grokfndecl (ctype, type, declarator, declarator,
11271                                virtualp, flags, quals, raises,
11272                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11273                                template_count, in_namespace);
11274             if (decl == NULL_TREE)
11275               return NULL_TREE;
11276           }
11277         else if (!staticp && ! processing_template_decl
11278                  && !COMPLETE_TYPE_P (complete_type (type))
11279                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11280           {
11281             if (declarator)
11282               cp_error ("field `%D' has incomplete type", declarator);
11283             else
11284               cp_error ("name `%T' has incomplete type", type);
11285
11286             /* If we're instantiating a template, tell them which
11287                instantiation made the field's type be incomplete.  */
11288             if (current_class_type
11289                 && TYPE_NAME (current_class_type)
11290                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11291                 && declspecs && TREE_VALUE (declspecs)
11292                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11293               cp_error ("  in instantiation of template `%T'",
11294                         current_class_type);
11295
11296             type = error_mark_node;
11297             decl = NULL_TREE;
11298           }
11299         else
11300           {
11301             if (friendp)
11302               {
11303                 error ("`%s' is neither function nor member function; cannot be declared friend",
11304                        IDENTIFIER_POINTER (declarator));
11305                 friendp = 0;
11306               }
11307             decl = NULL_TREE;
11308           }
11309
11310         if (friendp)
11311           {
11312             /* Friends are treated specially.  */
11313             if (ctype == current_class_type)
11314               warning ("member functions are implicitly friends of their class");
11315             else
11316               {
11317                 tree t = NULL_TREE;
11318                 if (decl && DECL_NAME (decl))
11319                   {
11320                     if (template_class_depth (current_class_type) == 0)
11321                       {
11322                         decl
11323                           = check_explicit_specialization
11324                           (declarator, decl,
11325                            template_count, 2 * (funcdef_flag != 0) + 4);
11326                         if (decl == error_mark_node)
11327                           return error_mark_node;
11328                       }
11329
11330                     t = do_friend (ctype, declarator, decl,
11331                                    last_function_parms, attrlist, flags, quals,
11332                                    funcdef_flag);
11333                   }
11334                 if (t && funcdef_flag)
11335                   return t;
11336
11337                 return void_type_node;
11338               }
11339           }
11340
11341         /* Structure field.  It may not be a function, except for C++ */
11342
11343         if (decl == NULL_TREE)
11344           {
11345             if (initialized)
11346               {
11347                 if (!staticp)
11348                   {
11349                     /* An attempt is being made to initialize a non-static
11350                        member.  But, from [class.mem]:
11351
11352                        4 A member-declarator can contain a
11353                        constant-initializer only if it declares a static
11354                        member (_class.static_) of integral or enumeration
11355                        type, see _class.static.data_.
11356
11357                        This used to be relatively common practice, but
11358                        the rest of the compiler does not correctly
11359                        handle the initialization unless the member is
11360                        static so we make it static below.  */
11361                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11362                                 declarator);
11363                     cp_pedwarn ("making `%D' static", declarator);
11364                     staticp = 1;
11365                   }
11366
11367                 if (uses_template_parms (type))
11368                   /* We'll check at instantiation time.  */
11369                   ;
11370                 else if (check_static_variable_definition (declarator,
11371                                                            type))
11372                   /* If we just return the declaration, crashes
11373                      will sometimes occur.  We therefore return
11374                      void_type_node, as if this was a friend
11375                      declaration, to cause callers to completely
11376                      ignore this declaration.  */
11377                   return void_type_node;
11378               }
11379
11380             /* 9.2p13 [class.mem] */
11381             if (declarator == constructor_name (current_class_type)
11382                 /* Divergence from the standard:  In extern "C", we
11383                    allow non-static data members here, because C does
11384                    and /usr/include/netinet/in.h uses that.  */
11385                 && (staticp || ! in_system_header))
11386               cp_pedwarn ("ISO C++ forbids data member `%D' with same name as enclosing class",
11387                           declarator);
11388
11389             if (staticp)
11390               {
11391                 /* C++ allows static class members.  All other work
11392                    for this is done by grokfield.  */
11393                 decl = build_lang_decl (VAR_DECL, declarator, type);
11394                 TREE_STATIC (decl) = 1;
11395                 /* In class context, 'static' means public access.  */
11396                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11397               }
11398             else
11399               {
11400                 decl = build_lang_decl (FIELD_DECL, declarator, type);
11401                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11402                   {
11403                     DECL_MUTABLE_P (decl) = 1;
11404                     RIDBIT_RESET (RID_MUTABLE, specbits);
11405                   }
11406               }
11407
11408             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11409                             inlinep, friendp, raises != NULL_TREE);
11410           }
11411       }
11412     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11413       {
11414         tree original_name;
11415         int publicp = 0;
11416
11417         if (! declarator)
11418           return NULL_TREE;
11419
11420         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11421           original_name = dname;
11422         else
11423           original_name = declarator;
11424
11425         if (RIDBIT_SETP (RID_AUTO, specbits))
11426           error ("storage class `auto' invalid for function `%s'", name);
11427         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11428           error ("storage class `register' invalid for function `%s'", name);
11429
11430         /* Function declaration not at top level.
11431            Storage classes other than `extern' are not allowed
11432            and `extern' makes no difference.  */
11433         if (! toplevel_bindings_p ()
11434             && (RIDBIT_SETP (RID_STATIC, specbits)
11435                 || RIDBIT_SETP (RID_INLINE, specbits))
11436             && pedantic)
11437           {
11438             if (RIDBIT_SETP (RID_STATIC, specbits))
11439               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11440             else
11441               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11442           }
11443
11444         if (ctype == NULL_TREE)
11445           {
11446             if (virtualp)
11447               {
11448                 error ("virtual non-class function `%s'", name);
11449                 virtualp = 0;
11450               }
11451           }
11452         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11453           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11454                                           TYPE_ARG_TYPES (type));
11455
11456         /* Record presence of `static'.  */
11457         publicp = (ctype != NULL_TREE
11458                    || RIDBIT_SETP (RID_EXTERN, specbits)
11459                    || !RIDBIT_SETP (RID_STATIC, specbits));
11460
11461         decl = grokfndecl (ctype, type, original_name, declarator,
11462                            virtualp, flags, quals, raises,
11463                            1, friendp,
11464                            publicp, inlinep, funcdef_flag,
11465                            template_count, in_namespace);
11466         if (decl == NULL_TREE)
11467           return NULL_TREE;
11468
11469         if (staticp == 1)
11470           {
11471             int illegal_static = 0;
11472
11473             /* Don't allow a static member function in a class, and forbid
11474                declaring main to be static.  */
11475             if (TREE_CODE (type) == METHOD_TYPE)
11476               {
11477                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11478                 illegal_static = 1;
11479               }
11480             else if (current_function_decl)
11481               {
11482                 /* FIXME need arm citation */
11483                 error ("cannot declare static function inside another function");
11484                 illegal_static = 1;
11485               }
11486
11487             if (illegal_static)
11488               {
11489                 staticp = 0;
11490                 RIDBIT_RESET (RID_STATIC, specbits);
11491               }
11492           }
11493       }
11494     else
11495       {
11496         /* It's a variable.  */
11497
11498         /* An uninitialized decl with `extern' is a reference.  */
11499         decl = grokvardecl (type, declarator, &specbits,
11500                             initialized,
11501                             (type_quals & TYPE_QUAL_CONST) != 0,
11502                             in_namespace);
11503         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11504                         inlinep, friendp, raises != NULL_TREE);
11505
11506         if (ctype)
11507           {
11508             DECL_CONTEXT (decl) = ctype;
11509             if (staticp == 1)
11510               {
11511                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11512                 staticp = 0;
11513                 RIDBIT_RESET (RID_STATIC, specbits);
11514               }
11515             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11516               {
11517                 cp_error ("static member `%D' declared `register'", decl);
11518                 RIDBIT_RESET (RID_REGISTER, specbits);
11519               }
11520             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11521               {
11522                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11523                             decl);
11524                 RIDBIT_RESET (RID_EXTERN, specbits);
11525               }
11526           }
11527       }
11528
11529     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11530
11531     /* Record `register' declaration for warnings on &
11532        and in case doing stupid register allocation.  */
11533
11534     if (RIDBIT_SETP (RID_REGISTER, specbits))
11535       DECL_REGISTER (decl) = 1;
11536
11537     if (RIDBIT_SETP (RID_EXTERN, specbits))
11538       DECL_THIS_EXTERN (decl) = 1;
11539
11540     if (RIDBIT_SETP (RID_STATIC, specbits))
11541       DECL_THIS_STATIC (decl) = 1;
11542
11543     /* Record constancy and volatility.  There's no need to do this
11544        when processing a template; we'll do this for the instantiated
11545        declaration based on the type of DECL.  */
11546     if (!processing_template_decl)
11547       c_apply_type_quals_to_decl (type_quals, decl);
11548
11549     return decl;
11550   }
11551 }
11552 \f
11553 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11554    An empty exprlist is a parmlist.  An exprlist which
11555    contains only identifiers at the global level
11556    is a parmlist.  Otherwise, it is an exprlist.  */
11557
11558 int
11559 parmlist_is_exprlist (exprs)
11560      tree exprs;
11561 {
11562   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11563     return 0;
11564
11565   if (toplevel_bindings_p ())
11566     {
11567       /* At the global level, if these are all identifiers,
11568          then it is a parmlist.  */
11569       while (exprs)
11570         {
11571           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11572             return 1;
11573           exprs = TREE_CHAIN (exprs);
11574         }
11575       return 0;
11576     }
11577   return 1;
11578 }
11579
11580 /* Subroutine of start_function.  Ensure that each of the parameter
11581    types (as listed in PARMS) is complete, as is required for a
11582    function definition.  */
11583
11584 static void
11585 require_complete_types_for_parms (parms)
11586      tree parms;
11587 {
11588   for (; parms; parms = TREE_CHAIN (parms))
11589     {
11590       tree type = TREE_TYPE (parms);
11591
11592       /* Try to complete the TYPE.  */
11593       type = complete_type (type);
11594
11595       if (type == error_mark_node)
11596         continue;
11597
11598       if (!COMPLETE_TYPE_P (type))
11599         {
11600           if (DECL_NAME (parms))
11601             error ("parameter `%s' has incomplete type",
11602                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11603           else
11604             error ("parameter has incomplete type");
11605           TREE_TYPE (parms) = error_mark_node;
11606         }
11607       else
11608         layout_decl (parms, 0);
11609     }
11610 }
11611
11612 /* Returns non-zero if T is a local variable.  */
11613
11614 int
11615 local_variable_p (t)
11616      tree t;
11617 {
11618   if ((TREE_CODE (t) == VAR_DECL
11619        /* A VAR_DECL with a context that is a _TYPE is a static data
11620           member.  */
11621        && !TYPE_P (CP_DECL_CONTEXT (t))
11622        /* Any other non-local variable must be at namespace scope.  */
11623        && !DECL_NAMESPACE_SCOPE_P (t))
11624       || (TREE_CODE (t) == PARM_DECL))
11625     return 1;
11626
11627   return 0;
11628 }
11629
11630 /* Returns non-zero if T is an automatic local variable or a label.
11631    (These are the declarations that need to be remapped when the code
11632    containing them is duplicated.)  */
11633
11634 int
11635 nonstatic_local_decl_p (t)
11636      tree t;
11637 {
11638   return ((local_variable_p (t) && !TREE_STATIC (t))
11639           || TREE_CODE (t) == LABEL_DECL
11640           || TREE_CODE (t) == RESULT_DECL);
11641 }
11642
11643 /* Like local_variable_p, but suitable for use as a tree-walking
11644    function.  */
11645
11646 static tree
11647 local_variable_p_walkfn (tp, walk_subtrees, data)
11648      tree *tp;
11649      int *walk_subtrees ATTRIBUTE_UNUSED;
11650      void *data ATTRIBUTE_UNUSED;
11651 {
11652   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11653           ? *tp : NULL_TREE);
11654 }
11655
11656 /* Check that ARG, which is a default-argument expression for a
11657    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11658    something goes wrong.  DECL may also be a _TYPE node, rather than a
11659    DECL, if there is no DECL available.  */
11660
11661 tree
11662 check_default_argument (decl, arg)
11663      tree decl;
11664      tree arg;
11665 {
11666   tree var;
11667   tree decl_type;
11668
11669   if (TREE_CODE (arg) == DEFAULT_ARG)
11670     /* We get a DEFAULT_ARG when looking at an in-class declaration
11671        with a default argument.  Ignore the argument for now; we'll
11672        deal with it after the class is complete.  */
11673     return arg;
11674
11675   if (processing_template_decl || uses_template_parms (arg))
11676     /* We don't do anything checking until instantiation-time.  Note
11677        that there may be uninstantiated arguments even for an
11678        instantiated function, since default arguments are not
11679        instantiated until they are needed.  */
11680     return arg;
11681
11682   if (TYPE_P (decl))
11683     {
11684       decl_type = decl;
11685       decl = NULL_TREE;
11686     }
11687   else
11688     decl_type = TREE_TYPE (decl);
11689
11690   if (arg == error_mark_node
11691       || decl == error_mark_node
11692       || TREE_TYPE (arg) == error_mark_node
11693       || decl_type == error_mark_node)
11694     /* Something already went wrong.  There's no need to check
11695        further.  */
11696     return error_mark_node;
11697
11698   /* [dcl.fct.default]
11699
11700      A default argument expression is implicitly converted to the
11701      parameter type.  */
11702   if (!TREE_TYPE (arg)
11703       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11704     {
11705       if (decl)
11706         cp_error ("default argument for `%#D' has type `%T'",
11707                   decl, TREE_TYPE (arg));
11708       else
11709         cp_error ("default argument for parameter of type `%T' has type `%T'",
11710                   decl_type, TREE_TYPE (arg));
11711
11712       return error_mark_node;
11713     }
11714
11715   /* [dcl.fct.default]
11716
11717      Local variables shall not be used in default argument
11718      expressions.
11719
11720      The keyword `this' shall not be used in a default argument of a
11721      member function.  */
11722   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11723   if (var)
11724     {
11725       cp_error ("default argument `%E' uses local variable `%D'",
11726                 arg, var);
11727       return error_mark_node;
11728     }
11729
11730   /* All is well.  */
11731   return arg;
11732 }
11733
11734 /* Decode the list of parameter types for a function type.
11735    Given the list of things declared inside the parens,
11736    return a list of types.
11737
11738    The list we receive can have three kinds of elements:
11739    an IDENTIFIER_NODE for names given without types,
11740    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11741    or void_type_node, to mark the end of an argument list
11742    when additional arguments are not permitted (... was not used).
11743
11744    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11745    a mere declaration.  A nonempty identifier-list gets an error message
11746    when FUNCDEF_FLAG is zero.
11747    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11748    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11749
11750    If all elements of the input list contain types,
11751    we return a list of the types.
11752    If all elements contain no type (except perhaps a void_type_node
11753    at the end), we return a null list.
11754    If some have types and some do not, it is an error, and we
11755    return a null list.
11756
11757    Also set last_function_parms to either
11758    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11759    A list of names is converted to a chain of PARM_DECLs
11760    by store_parm_decls so that ultimately it is always a chain of decls.
11761
11762    Note that in C++, parameters can take default values.  These default
11763    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11764    an error to specify default values which are followed by parameters
11765    that have no default values, or an ELLIPSES.  For simplicities sake,
11766    only parameters which are specified with their types can take on
11767    default values.  */
11768
11769 static tree
11770 grokparms (first_parm, funcdef_flag)
11771      tree first_parm;
11772      int funcdef_flag;
11773 {
11774   tree result = NULL_TREE;
11775   tree decls = NULL_TREE;
11776
11777   if (first_parm != NULL_TREE
11778       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11779     {
11780       if (! funcdef_flag)
11781         pedwarn ("parameter names (without types) in function declaration");
11782       last_function_parms = first_parm;
11783       return NULL_TREE;
11784     }
11785   else if (first_parm != NULL_TREE
11786            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11787            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11788     my_friendly_abort (145);
11789   else
11790     {
11791       /* Types were specified.  This is a list of declarators
11792          each represented as a TREE_LIST node.  */
11793       register tree parm, chain;
11794       int any_init = 0, any_error = 0;
11795
11796       if (first_parm != NULL_TREE)
11797         {
11798           tree last_result = NULL_TREE;
11799           tree last_decl = NULL_TREE;
11800
11801           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11802             {
11803               tree type = NULL_TREE, list_node = parm;
11804               register tree decl = TREE_VALUE (parm);
11805               tree init = TREE_PURPOSE (parm);
11806
11807               chain = TREE_CHAIN (parm);
11808               /* @@ weak defense against parse errors.  */
11809               if (TREE_CODE (decl) != VOID_TYPE
11810                   && TREE_CODE (decl) != TREE_LIST)
11811                 {
11812                   /* Give various messages as the need arises.  */
11813                   if (TREE_CODE (decl) == STRING_CST)
11814                     cp_error ("invalid string constant `%E'", decl);
11815                   else if (TREE_CODE (decl) == INTEGER_CST)
11816                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11817                   continue;
11818                 }
11819
11820               if (TREE_CODE (decl) != VOID_TYPE)
11821                 {
11822                   decl = grokdeclarator (TREE_VALUE (decl),
11823                                          TREE_PURPOSE (decl),
11824                                          PARM, init != NULL_TREE,
11825                                          NULL_TREE);
11826                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11827                     continue;
11828
11829                   /* Top-level qualifiers on the parameters are
11830                      ignored for function types.  */
11831                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11832
11833                   if (TREE_CODE (type) == VOID_TYPE)
11834                     decl = void_type_node;
11835                   else if (TREE_CODE (type) == METHOD_TYPE)
11836                     {
11837                       if (DECL_NAME (decl))
11838                         /* Cannot use the decl here because
11839                            we don't have DECL_CONTEXT set up yet.  */
11840                         cp_error ("parameter `%D' invalidly declared method type",
11841                                   DECL_NAME (decl));
11842                       else
11843                         error ("parameter invalidly declared method type");
11844                       type = build_pointer_type (type);
11845                       TREE_TYPE (decl) = type;
11846                     }
11847                   else if (TREE_CODE (type) == OFFSET_TYPE)
11848                     {
11849                       if (DECL_NAME (decl))
11850                         cp_error ("parameter `%D' invalidly declared offset type",
11851                                   DECL_NAME (decl));
11852                       else
11853                         error ("parameter invalidly declared offset type");
11854                       type = build_pointer_type (type);
11855                       TREE_TYPE (decl) = type;
11856                     }
11857                   else if (abstract_virtuals_error (decl, type))
11858                     any_error = 1;  /* Seems like a good idea. */
11859                   else if (POINTER_TYPE_P (type))
11860                     {
11861                       tree t = type;
11862                       while (POINTER_TYPE_P (t)
11863                              || (TREE_CODE (t) == ARRAY_TYPE
11864                                  && TYPE_DOMAIN (t) != NULL_TREE))
11865                         t = TREE_TYPE (t);
11866                       if (TREE_CODE (t) == ARRAY_TYPE)
11867                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
11868                                   type,
11869                                   TYPE_PTR_P (type) ? "pointer" : "reference");
11870                     }
11871                 }
11872
11873               if (TREE_CODE (decl) == VOID_TYPE)
11874                 {
11875                   if (result == NULL_TREE)
11876                     {
11877                       result = void_list_node;
11878                       last_result = result;
11879                     }
11880                   else
11881                     {
11882                       TREE_CHAIN (last_result) = void_list_node;
11883                       last_result = void_list_node;
11884                     }
11885                   if (chain
11886                       && (chain != void_list_node || TREE_CHAIN (chain)))
11887                     error ("`void' in parameter list must be entire list");
11888                   break;
11889                 }
11890
11891               /* Since there is a prototype, args are passed in their own types.  */
11892               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11893               if (PROMOTE_PROTOTYPES
11894                   && (TREE_CODE (type) == INTEGER_TYPE
11895                       || TREE_CODE (type) == ENUMERAL_TYPE)
11896                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11897                 DECL_ARG_TYPE (decl) = integer_type_node;
11898               if (!any_error && init)
11899                 {
11900                   any_init++;
11901                   init = check_default_argument (decl, init);
11902                 }
11903               else
11904                 init = NULL_TREE;
11905
11906               if (decls == NULL_TREE)
11907                 {
11908                   decls = decl;
11909                   last_decl = decls;
11910                 }
11911               else
11912                 {
11913                   TREE_CHAIN (last_decl) = decl;
11914                   last_decl = decl;
11915                 }
11916               list_node = tree_cons (init, type, NULL_TREE);
11917               if (result == NULL_TREE)
11918                 {
11919                   result = list_node;
11920                   last_result = result;
11921                 }
11922               else
11923                 {
11924                   TREE_CHAIN (last_result) = list_node;
11925                   last_result = list_node;
11926                 }
11927             }
11928           if (last_result)
11929             TREE_CHAIN (last_result) = NULL_TREE;
11930           /* If there are no parameters, and the function does not end
11931              with `...', then last_decl will be NULL_TREE.  */
11932           if (last_decl != NULL_TREE)
11933             TREE_CHAIN (last_decl) = NULL_TREE;
11934         }
11935     }
11936
11937   last_function_parms = decls;
11938
11939   return result;
11940 }
11941
11942 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11943    FUNCTION_TYPE with the newly parsed version of its default argument, which
11944    was previously digested as text.  See snarf_defarg et al in lex.c.  */
11945
11946 void
11947 replace_defarg (arg, init)
11948      tree arg, init;
11949 {
11950   if (! processing_template_decl
11951       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11952     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11953                 TREE_TYPE (init), TREE_VALUE (arg));
11954   TREE_PURPOSE (arg) = init;
11955 }
11956 \f
11957 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11958    D's arguments allow it to be a copy constructor, or copy assignment
11959    operator.  */
11960
11961 int
11962 copy_args_p (d)
11963      tree d;
11964 {
11965   tree t;
11966
11967   if (!DECL_FUNCTION_MEMBER_P (d))
11968     return 0;
11969
11970   t = FUNCTION_ARG_CHAIN (d);
11971   if (DECL_CONSTRUCTOR_P (d)
11972       && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
11973     t = TREE_CHAIN (t);
11974   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11975       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11976           == DECL_CONTEXT (d))
11977       && (TREE_CHAIN (t) == NULL_TREE
11978           || TREE_CHAIN (t) == void_list_node
11979           || TREE_PURPOSE (TREE_CHAIN (t))))
11980     return 1;
11981   return 0;
11982 }
11983
11984 /* These memoizing functions keep track of special properties which
11985    a class may have.  `grok_ctor_properties' notices whether a class
11986    has a constructor of the form X(X&), and also complains
11987    if the class has a constructor of the form X(X).
11988    `grok_op_properties' takes notice of the various forms of
11989    operator= which are defined, as well as what sorts of type conversion
11990    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11991
11992 int
11993 grok_ctor_properties (ctype, decl)
11994      tree ctype, decl;
11995 {
11996   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11997   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11998
11999   /* When a type has virtual baseclasses, a magical first int argument is
12000      added to any ctor so we can tell if the class has been initialized
12001      yet.  This could screw things up in this function, so we deliberately
12002      ignore the leading int if we're in that situation.  */
12003   if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
12004     {
12005       my_friendly_assert (parmtypes
12006                           && TREE_VALUE (parmtypes) == integer_type_node,
12007                           980529);
12008       parmtypes = TREE_CHAIN (parmtypes);
12009       parmtype = TREE_VALUE (parmtypes);
12010     }
12011
12012   /* [class.copy]
12013
12014      A non-template constructor for class X is a copy constructor if
12015      its first parameter is of type X&, const X&, volatile X& or const
12016      volatile X&, and either there are no other parameters or else all
12017      other parameters have default arguments.  */
12018   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12019       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12020       && (TREE_CHAIN (parmtypes) == NULL_TREE
12021           || TREE_CHAIN (parmtypes) == void_list_node
12022           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12023       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12024            && is_member_template (DECL_TI_TEMPLATE (decl))))
12025     {
12026       TYPE_HAS_INIT_REF (ctype) = 1;
12027       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12028         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12029     }
12030   /* [class.copy]
12031
12032      A declaration of a constructor for a class X is ill-formed if its
12033      first parameter is of type (optionally cv-qualified) X and either
12034      there are no other parameters or else all other parameters have
12035      default arguments.
12036
12037      We *don't* complain about member template instantiations that
12038      have this form, though; they can occur as we try to decide what
12039      constructor to use during overload resolution.  Since overload
12040      resolution will never prefer such a constructor to the
12041      non-template copy constructor (which is either explicitly or
12042      implicitly defined), there's no need to worry about their
12043      existence.  Theoretically, they should never even be
12044      instantiated, but that's hard to forestall.  */
12045   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12046            && (TREE_CHAIN (parmtypes) == NULL_TREE
12047                || TREE_CHAIN (parmtypes) == void_list_node
12048                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12049            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12050                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12051     {
12052       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12053                 ctype, ctype);
12054       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12055       return 0;
12056     }
12057   else if (TREE_CODE (parmtype) == VOID_TYPE
12058            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12059     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12060
12061   return 1;
12062 }
12063
12064 /* An operator with this name can be either unary or binary.  */
12065
12066 static int
12067 ambi_op_p (name)
12068      tree name;
12069 {
12070   return (name == ansi_opname [(int) INDIRECT_REF]
12071           || name == ansi_opname [(int) ADDR_EXPR]
12072           || name == ansi_opname [(int) NEGATE_EXPR]
12073           || name == ansi_opname[(int) POSTINCREMENT_EXPR]
12074           || name == ansi_opname[(int) POSTDECREMENT_EXPR]
12075           || name == ansi_opname [(int) CONVERT_EXPR]);
12076 }
12077
12078 /* An operator with this name can only be unary.  */
12079
12080 static int
12081 unary_op_p (name)
12082      tree name;
12083 {
12084   return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
12085           || name == ansi_opname [(int) BIT_NOT_EXPR]
12086           || name == ansi_opname [(int) COMPONENT_REF]
12087           || IDENTIFIER_TYPENAME_P (name));
12088 }
12089
12090 /* Do a little sanity-checking on how they declared their operator.  */
12091
12092 void
12093 grok_op_properties (decl, virtualp, friendp)
12094      tree decl;
12095      int virtualp, friendp;
12096 {
12097   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12098   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12099   tree name = DECL_NAME (decl);
12100
12101   if (current_class_type == NULL_TREE)
12102     friendp = 1;
12103
12104   if (! friendp)
12105     {
12106       /* [class.copy]
12107
12108          A user-declared copy assignment operator X::operator= is a
12109          non-static non-template member function of class X with
12110          exactly one parameter of type X, X&, const X&, volatile X& or
12111          const volatile X&.  */
12112       if (name == ansi_opname[(int) MODIFY_EXPR]
12113           && !(DECL_TEMPLATE_INSTANTIATION (decl)
12114                && is_member_template (DECL_TI_TEMPLATE (decl))))
12115         ;
12116       else if (name == ansi_opname[(int) CALL_EXPR])
12117         TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12118       else if (name == ansi_opname[(int) ARRAY_REF])
12119         TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12120       else if (name == ansi_opname[(int) COMPONENT_REF]
12121                || name == ansi_opname[(int) MEMBER_REF])
12122         TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12123       else if (name == ansi_opname[(int) NEW_EXPR])
12124         TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12125       else if (name == ansi_opname[(int) DELETE_EXPR])
12126         TYPE_GETS_DELETE (current_class_type) |= 1;
12127       else if (name == ansi_opname[(int) VEC_NEW_EXPR])
12128         TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12129       else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
12130         TYPE_GETS_DELETE (current_class_type) |= 2;
12131     }
12132
12133   if (name == ansi_opname[(int) NEW_EXPR]
12134       || name == ansi_opname[(int) VEC_NEW_EXPR])
12135     {
12136       /* When the compiler encounters the definition of A::operator new, it
12137          doesn't look at the class declaration to find out if it's static.  */
12138       if (methodp)
12139         revert_static_member_fn (decl);
12140
12141       /* Take care of function decl if we had syntax errors.  */
12142       if (argtypes == NULL_TREE)
12143         TREE_TYPE (decl)
12144           = build_function_type (ptr_type_node,
12145                                  hash_tree_chain (integer_type_node,
12146                                                   void_list_node));
12147       else
12148         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12149     }
12150   else if (name == ansi_opname[(int) DELETE_EXPR]
12151            || name == ansi_opname[(int) VEC_DELETE_EXPR])
12152     {
12153       if (methodp)
12154         revert_static_member_fn (decl);
12155
12156       if (argtypes == NULL_TREE)
12157         TREE_TYPE (decl)
12158           = build_function_type (void_type_node,
12159                                  hash_tree_chain (ptr_type_node,
12160                                                   void_list_node));
12161       else
12162         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12163     }
12164   else
12165     {
12166       /* An operator function must either be a non-static member function
12167          or have at least one parameter of a class, a reference to a class,
12168          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12169       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12170         {
12171           if (IDENTIFIER_TYPENAME_P (name)
12172               || name == ansi_opname[(int) CALL_EXPR]
12173               || name == ansi_opname[(int) MODIFY_EXPR]
12174               || name == ansi_opname[(int) COMPONENT_REF]
12175               || name == ansi_opname[(int) ARRAY_REF])
12176             cp_error ("`%D' must be a nonstatic member function", decl);
12177           else
12178             {
12179               tree p = argtypes;
12180
12181               if (DECL_STATIC_FUNCTION_P (decl))
12182                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12183
12184               if (p)
12185                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12186                   {
12187                     tree arg = TREE_VALUE (p);
12188                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12189                       arg = TREE_TYPE (arg);
12190
12191                     /* This lets bad template code slip through.  */
12192                     if (IS_AGGR_TYPE (arg)
12193                         || TREE_CODE (arg) == ENUMERAL_TYPE
12194                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12195                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12196                       goto foundaggr;
12197                   }
12198               cp_error
12199                 ("`%D' must have an argument of class or enumerated type",
12200                  decl);
12201             foundaggr:
12202               ;
12203             }
12204         }
12205
12206       if (name == ansi_opname[(int) CALL_EXPR])
12207         return;                 /* No restrictions on args. */
12208
12209       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12210         {
12211           tree t = TREE_TYPE (name);
12212           if (! friendp)
12213             {
12214               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12215               const char *what = 0;
12216
12217               if (ref)
12218                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12219
12220               if (TREE_CODE (t) == VOID_TYPE)
12221                 what = "void";
12222               else if (t == current_class_type)
12223                 what = "the same type";
12224               /* Don't force t to be complete here.  */
12225               else if (IS_AGGR_TYPE (t)
12226                        && COMPLETE_TYPE_P (t)
12227                        && DERIVED_FROM_P (t, current_class_type))
12228                 what = "a base class";
12229
12230               if (what)
12231                 warning ("conversion to %s%s will never use a type conversion operator",
12232                          ref ? "a reference to " : "", what);
12233             }
12234         }
12235
12236       if (name == ansi_opname[(int) MODIFY_EXPR])
12237         {
12238           tree parmtype;
12239
12240           if (list_length (argtypes) != 3 && methodp)
12241             {
12242               cp_error ("`%D' must take exactly one argument", decl);
12243               return;
12244             }
12245           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12246
12247           if (copy_assignment_arg_p (parmtype, virtualp)
12248               && ! friendp)
12249             {
12250               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12251               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12252                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12253                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12254             }
12255         }
12256       else if (name == ansi_opname[(int) COND_EXPR])
12257         {
12258           /* 13.4.0.3 */
12259           cp_error ("ISO C++ prohibits overloading operator ?:");
12260         }
12261       else if (ambi_op_p (name))
12262         {
12263           if (list_length (argtypes) == 2)
12264             /* prefix */;
12265           else if (list_length (argtypes) == 3)
12266             {
12267               if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
12268                    || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12269                   && ! processing_template_decl
12270                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12271                 {
12272                   if (methodp)
12273                     cp_error ("postfix `%D' must take `int' as its argument",
12274                               decl);
12275                   else
12276                     cp_error
12277                       ("postfix `%D' must take `int' as its second argument",
12278                        decl);
12279                 }
12280             }
12281           else
12282             {
12283               if (methodp)
12284                 cp_error ("`%D' must take either zero or one argument", decl);
12285               else
12286                 cp_error ("`%D' must take either one or two arguments", decl);
12287             }
12288
12289           /* More Effective C++ rule 6.  */
12290           if (warn_ecpp
12291               && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12292                   || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
12293             {
12294               tree arg = TREE_VALUE (argtypes);
12295               tree ret = TREE_TYPE (TREE_TYPE (decl));
12296               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12297                 arg = TREE_TYPE (arg);
12298               arg = TYPE_MAIN_VARIANT (arg);
12299               if (list_length (argtypes) == 2)
12300                 {
12301                   if (TREE_CODE (ret) != REFERENCE_TYPE
12302                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12303                                        arg))
12304                     cp_warning ("prefix `%D' should return `%T'", decl,
12305                                 build_reference_type (arg));
12306                 }
12307               else
12308                 {
12309                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12310                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12311                 }
12312             }
12313         }
12314       else if (unary_op_p (name))
12315         {
12316           if (list_length (argtypes) != 2)
12317             {
12318               if (methodp)
12319                 cp_error ("`%D' must take `void'", decl);
12320               else
12321                 cp_error ("`%D' must take exactly one argument", decl);
12322             }
12323         }
12324       else /* if (binary_op_p (name)) */
12325         {
12326           if (list_length (argtypes) != 3)
12327             {
12328               if (methodp)
12329                 cp_error ("`%D' must take exactly one argument", decl);
12330               else
12331                 cp_error ("`%D' must take exactly two arguments", decl);
12332             }
12333
12334           /* More Effective C++ rule 7.  */
12335           if (warn_ecpp
12336               && (name == ansi_opname [TRUTH_ANDIF_EXPR]
12337                   || name == ansi_opname [TRUTH_ORIF_EXPR]
12338                   || name == ansi_opname [COMPOUND_EXPR]))
12339             cp_warning ("user-defined `%D' always evaluates both arguments",
12340                         decl);
12341         }
12342
12343       /* Effective C++ rule 23.  */
12344       if (warn_ecpp
12345           && list_length (argtypes) == 3
12346           && (name == ansi_opname [PLUS_EXPR]
12347               || name == ansi_opname [MINUS_EXPR]
12348               || name == ansi_opname [TRUNC_DIV_EXPR]
12349               || name == ansi_opname [MULT_EXPR])
12350           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12351         cp_warning ("`%D' should return by value", decl);
12352
12353       /* 13.4.0.8 */
12354       if (argtypes)
12355         for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
12356           if (TREE_PURPOSE (argtypes))
12357             {
12358               TREE_PURPOSE (argtypes) = NULL_TREE;
12359               if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12360                   || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12361                 {
12362                   if (pedantic)
12363                     cp_pedwarn ("`%D' cannot have default arguments", decl);
12364                 }
12365               else
12366                 cp_error ("`%D' cannot have default arguments", decl);
12367             }
12368     }
12369 }
12370 \f
12371 static const char *
12372 tag_name (code)
12373      enum tag_types code;
12374 {
12375   switch (code)
12376     {
12377     case record_type:
12378       return "struct";
12379     case class_type:
12380       return "class";
12381     case union_type:
12382       return "union ";
12383     case enum_type:
12384       return "enum";
12385     default:
12386       my_friendly_abort (981122);
12387     }
12388 }
12389
12390 /* Get the struct, enum or union (CODE says which) with tag NAME.
12391    Define the tag as a forward-reference if it is not defined.
12392
12393    C++: If a class derivation is given, process it here, and report
12394    an error if multiple derivation declarations are not identical.
12395
12396    If this is a definition, come in through xref_tag and only look in
12397    the current frame for the name (since C++ allows new names in any
12398    scope.)  */
12399
12400 tree
12401 xref_tag (code_type_node, name, globalize)
12402      tree code_type_node;
12403      tree name;
12404      int globalize;
12405 {
12406   enum tag_types tag_code;
12407   enum tree_code code;
12408   register tree ref, t;
12409   struct binding_level *b = current_binding_level;
12410   int got_type = 0;
12411   tree attributes = NULL_TREE;
12412   tree context = NULL_TREE;
12413
12414   /* If we are called from the parser, code_type_node will sometimes be a
12415      TREE_LIST.  This indicates that the user wrote
12416      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12417      use them later.  */
12418   if (TREE_CODE (code_type_node) == TREE_LIST)
12419     {
12420       attributes = TREE_PURPOSE (code_type_node);
12421       code_type_node = TREE_VALUE (code_type_node);
12422     }
12423
12424   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12425   switch (tag_code)
12426     {
12427     case record_type:
12428     case class_type:
12429       code = RECORD_TYPE;
12430       break;
12431     case union_type:
12432       code = UNION_TYPE;
12433       break;
12434     case enum_type:
12435       code = ENUMERAL_TYPE;
12436       break;
12437     default:
12438       my_friendly_abort (18);
12439     }
12440
12441   /* If a cross reference is requested, look up the type
12442      already defined for this tag and return it.  */
12443   if (TYPE_P (name))
12444     {
12445       t = name;
12446       name = TYPE_IDENTIFIER (t);
12447       got_type = 1;
12448     }
12449   else
12450     t = IDENTIFIER_TYPE_VALUE (name);
12451
12452   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12453       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12454     t = NULL_TREE;
12455
12456   if (! globalize)
12457     {
12458       /* If we know we are defining this tag, only look it up in
12459          this scope and don't try to find it as a type.  */
12460       ref = lookup_tag (code, name, b, 1);
12461     }
12462   else
12463     {
12464       if (t)
12465         {
12466           /* [dcl.type.elab] If the identifier resolves to a
12467              typedef-name or a template type-parameter, the
12468              elaborated-type-specifier is ill-formed.  */
12469           if (t != TYPE_MAIN_VARIANT (t)
12470               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12471             cp_pedwarn ("using typedef-name `%D' after `%s'",
12472                         TYPE_NAME (t), tag_name (tag_code));
12473           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12474             cp_error ("using template type parameter `%T' after `%s'",
12475                       t, tag_name (tag_code));
12476
12477           ref = t;
12478         }
12479       else
12480         ref = lookup_tag (code, name, b, 0);
12481
12482       if (! ref)
12483         {
12484           /* Try finding it as a type declaration.  If that wins,
12485              use it.  */
12486           ref = lookup_name (name, 1);
12487
12488           if (ref != NULL_TREE
12489               && processing_template_decl
12490               && DECL_CLASS_TEMPLATE_P (ref)
12491               && template_class_depth (current_class_type) == 0)
12492             /* Since GLOBALIZE is true, we're declaring a global
12493                template, so we want this type.  */
12494             ref = DECL_TEMPLATE_RESULT (ref);
12495
12496           if (ref && TREE_CODE (ref) == TYPE_DECL
12497               && TREE_CODE (TREE_TYPE (ref)) == code)
12498             ref = TREE_TYPE (ref);
12499           else
12500             ref = NULL_TREE;
12501         }
12502
12503       if (ref && current_class_type
12504           && template_class_depth (current_class_type)
12505           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12506         {
12507           /* Since GLOBALIZE is non-zero, we are not looking at a
12508              definition of this tag.  Since, in addition, we are currently
12509              processing a (member) template declaration of a template
12510              class, we must be very careful; consider:
12511
12512                template <class X>
12513                struct S1
12514
12515                template <class U>
12516                struct S2
12517                { template <class V>
12518                friend struct S1; };
12519
12520              Here, the S2::S1 declaration should not be confused with the
12521              outer declaration.  In particular, the inner version should
12522              have a template parameter of level 2, not level 1.  This
12523              would be particularly important if the member declaration
12524              were instead:
12525
12526                template <class V = U> friend struct S1;
12527
12528              say, when we should tsubst into `U' when instantiating
12529              S2.  On the other hand, when presented with:
12530
12531                  template <class T>
12532                  struct S1 {
12533                    template <class U>
12534                    struct S2 {};
12535                    template <class U>
12536                    friend struct S2;
12537                  };
12538
12539               we must find the inner binding eventually.  We
12540               accomplish this by making sure that the new type we
12541               create to represent this declaration has the right
12542               TYPE_CONTEXT.  */
12543           context = TYPE_CONTEXT (ref);
12544           ref = NULL_TREE;
12545         }
12546     }
12547
12548   if (! ref)
12549     {
12550       /* If no such tag is yet defined, create a forward-reference node
12551          and record it as the "definition".
12552          When a real declaration of this type is found,
12553          the forward-reference will be altered into a real type.  */
12554       if (code == ENUMERAL_TYPE)
12555         {
12556           cp_error ("use of enum `%#D' without previous declaration", name);
12557
12558           ref = make_node (ENUMERAL_TYPE);
12559
12560           /* Give the type a default layout like unsigned int
12561              to avoid crashing if it does not get defined.  */
12562           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12563           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12564           TREE_UNSIGNED (ref) = 1;
12565           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12566           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12567           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12568
12569           /* Enable us to recognize when a type is created in class context.
12570              To do nested classes correctly, this should probably be cleared
12571              out when we leave this classes scope.  Currently this in only
12572              done in `start_enum'.  */
12573
12574           pushtag (name, ref, globalize);
12575         }
12576       else
12577         {
12578           struct binding_level *old_b = class_binding_level;
12579
12580           ref = make_aggr_type (code);
12581           TYPE_CONTEXT (ref) = context;
12582
12583 #ifdef NONNESTED_CLASSES
12584           /* Class types don't nest the way enums do.  */
12585           class_binding_level = (struct binding_level *)0;
12586 #endif
12587           pushtag (name, ref, globalize);
12588           class_binding_level = old_b;
12589         }
12590     }
12591   else
12592     {
12593       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12594         redeclare_class_template (ref, current_template_parms);
12595     }
12596
12597   /* Until the type is defined, tentatively accept whatever
12598      structure tag the user hands us.  */
12599   if (!COMPLETE_TYPE_P (ref)
12600       && ref != current_class_type
12601       /* Have to check this, in case we have contradictory tag info.  */
12602       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12603     {
12604       if (tag_code == class_type)
12605         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12606       else if (tag_code == record_type)
12607         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12608     }
12609
12610   TREE_TYPE (ref) = attributes;
12611
12612   return ref;
12613 }
12614
12615 tree
12616 xref_tag_from_type (old, id, globalize)
12617      tree old, id;
12618      int globalize;
12619 {
12620   tree code_type_node;
12621
12622   if (TREE_CODE (old) == RECORD_TYPE)
12623     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12624                       ? class_type_node : record_type_node);
12625   else
12626     code_type_node = union_type_node;
12627
12628   if (id == NULL_TREE)
12629     id = TYPE_IDENTIFIER (old);
12630
12631   return xref_tag (code_type_node, id, globalize);
12632 }
12633
12634 /* REF is a type (named NAME), for which we have just seen some
12635    baseclasses.  BINFO is a list of those baseclasses; the
12636    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12637    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12638    struct, or union.  */
12639
12640 void
12641 xref_basetypes (code_type_node, name, ref, binfo)
12642      tree code_type_node;
12643      tree name, ref;
12644      tree binfo;
12645 {
12646   /* In the declaration `A : X, Y, ... Z' we mark all the types
12647      (A, X, Y, ..., Z) so we can check for duplicates.  */
12648   tree binfos;
12649   tree base;
12650
12651   int i, len;
12652   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12653
12654   if (tag_code == union_type)
12655     {
12656       cp_error ("derived union `%T' invalid", ref);
12657       return;
12658     }
12659
12660   len = list_length (binfo);
12661
12662   /* First, make sure that any templates in base-classes are
12663      instantiated.  This ensures that if we call ourselves recursively
12664      we do not get confused about which classes are marked and which
12665      are not.  */
12666   for (base = binfo; base; base = TREE_CHAIN (base))
12667     complete_type (TREE_VALUE (base));
12668
12669   SET_CLASSTYPE_MARKED (ref);
12670   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12671
12672   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12673     {
12674       /* The base of a derived struct is public by default.  */
12675       int via_public
12676         = (TREE_PURPOSE (binfo) == access_public_node
12677            || TREE_PURPOSE (binfo) == access_public_virtual_node
12678            || (tag_code != class_type
12679                && (TREE_PURPOSE (binfo) == access_default_node
12680                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12681       int via_protected
12682         = (TREE_PURPOSE (binfo) == access_protected_node
12683            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12684       int via_virtual
12685         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12686            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12687            || TREE_PURPOSE (binfo) == access_public_virtual_node
12688            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12689       tree basetype = TREE_VALUE (binfo);
12690       tree base_binfo;
12691
12692       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12693         basetype = TREE_TYPE (basetype);
12694       if (!basetype
12695           || (TREE_CODE (basetype) != RECORD_TYPE
12696               && TREE_CODE (basetype) != TYPENAME_TYPE
12697               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12698               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12699         {
12700           cp_error ("base type `%T' fails to be a struct or class type",
12701                     TREE_VALUE (binfo));
12702           continue;
12703         }
12704
12705       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12706
12707       /* This code replaces similar code in layout_basetypes.
12708          We put the complete_type first for implicit `typename'.  */
12709       if (!COMPLETE_TYPE_P (basetype)
12710           && ! (current_template_parms && uses_template_parms (basetype)))
12711         {
12712           cp_error ("base class `%T' has incomplete type", basetype);
12713           continue;
12714         }
12715       else
12716         {
12717           if (CLASSTYPE_MARKED (basetype))
12718             {
12719               if (basetype == ref)
12720                 cp_error ("recursive type `%T' undefined", basetype);
12721               else
12722                 cp_error ("duplicate base type `%T' invalid", basetype);
12723               continue;
12724             }
12725
12726           if (TYPE_FOR_JAVA (basetype)
12727               && (current_lang_stack
12728                   == &VARRAY_TREE (current_lang_base, 0)))
12729             TYPE_FOR_JAVA (ref) = 1;
12730
12731           /* Note that the BINFO records which describe individual
12732              inheritances are *not* shared in the lattice!  They
12733              cannot be shared because a given baseclass may be
12734              inherited with different `accessibility' by different
12735              derived classes.  (Each BINFO record describing an
12736              individual inheritance contains flags which say what
12737              the `accessibility' of that particular inheritance is.)  */
12738
12739           base_binfo
12740             = make_binfo (size_zero_node, basetype,
12741                           CLASS_TYPE_P (basetype)
12742                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12743                           CLASS_TYPE_P (basetype)
12744                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12745
12746           TREE_VEC_ELT (binfos, i) = base_binfo;
12747           TREE_VIA_PUBLIC (base_binfo) = via_public;
12748           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12749           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12750           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12751
12752           /* We need to unshare the binfos now so that lookups during class
12753              definition work.  */
12754           unshare_base_binfos (base_binfo);
12755
12756           SET_CLASSTYPE_MARKED (basetype);
12757
12758           /* We are free to modify these bits because they are meaningless
12759              at top level, and BASETYPE is a top-level type.  */
12760           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12761             {
12762               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12763               /* Converting to a virtual base class requires looking
12764                  up the offset of the virtual base.  */
12765               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12766             }
12767
12768           if (CLASS_TYPE_P (basetype))
12769             {
12770               TYPE_HAS_NEW_OPERATOR (ref)
12771                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12772               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12773                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12774               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12775               /* If the base-class uses multiple inheritance, so do we.  */
12776               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12777                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12778               /* Likewise, if converting to a base of the base may require
12779                  code, then we may need to generate code to convert to a
12780                  base as well.  */
12781               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12782                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12783             }
12784
12785           i += 1;
12786         }
12787     }
12788   if (i)
12789     TREE_VEC_LENGTH (binfos) = i;
12790   else
12791     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12792
12793   if (i > 1)
12794     {
12795       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12796       /* If there is more than one non-empty they cannot be at the same
12797          address.  */
12798       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12799     }
12800
12801   /* Unmark all the types.  */
12802   while (--i >= 0)
12803     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12804   CLEAR_CLASSTYPE_MARKED (ref);
12805
12806   /* Now that we know all the base-classes, set up the list of virtual
12807      bases.  */
12808   get_vbase_types (ref);
12809 }
12810
12811 \f
12812 /* Begin compiling the definition of an enumeration type.
12813    NAME is its name (or null if anonymous).
12814    Returns the type object, as yet incomplete.
12815    Also records info about it so that build_enumerator
12816    may be used to declare the individual values as they are read.  */
12817
12818 tree
12819 start_enum (name)
12820      tree name;
12821 {
12822   register tree enumtype = NULL_TREE;
12823   struct binding_level *b = current_binding_level;
12824
12825   /* If this is the real definition for a previous forward reference,
12826      fill in the contents in the same object that used to be the
12827      forward reference.  */
12828
12829   if (name != NULL_TREE)
12830     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12831
12832   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12833     {
12834       cp_error ("multiple definition of `%#T'", enumtype);
12835       cp_error_at ("previous definition here", enumtype);
12836       /* Clear out TYPE_VALUES, and start again.  */
12837       TYPE_VALUES (enumtype) = NULL_TREE;
12838     }
12839   else
12840     {
12841       enumtype = make_node (ENUMERAL_TYPE);
12842       pushtag (name, enumtype, 0);
12843     }
12844
12845   if (current_class_type)
12846     TREE_ADDRESSABLE (b->tags) = 1;
12847
12848   GNU_xref_decl (current_function_decl, enumtype);
12849   return enumtype;
12850 }
12851
12852 /* After processing and defining all the values of an enumeration type,
12853    install their decls in the enumeration type and finish it off.
12854    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12855    Returns ENUMTYPE.  */
12856
12857 tree
12858 finish_enum (enumtype)
12859      tree enumtype;
12860 {
12861   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12862   /* Calculate the maximum value of any enumerator in this type.  */
12863
12864   tree values = TYPE_VALUES (enumtype);
12865   if (values)
12866     {
12867       tree pair;
12868
12869       for (pair = values; pair; pair = TREE_CHAIN (pair))
12870         {
12871           tree decl;
12872           tree value;
12873
12874           /* The TREE_VALUE is a CONST_DECL for this enumeration
12875              constant.  */
12876           decl = TREE_VALUE (pair);
12877
12878           /* [dcl.enum]
12879
12880              Following the closing brace of an enum-specifier, each
12881              enumerator has the type of its enumeration.  Prior to the
12882              closing brace, the type of each enumerator is the type of
12883              its initializing value.  */
12884           TREE_TYPE (decl) = enumtype;
12885
12886           /* The DECL_INITIAL will be NULL if we are processing a
12887              template declaration and this enumeration constant had no
12888              explicit initializer.  */
12889           value = DECL_INITIAL (decl);
12890           if (value && !processing_template_decl)
12891             {
12892               /* Set the TREE_TYPE for the VALUE as well.  That's so
12893                  that when we call decl_constant_value we get an
12894                  entity of the right type (but with the constant
12895                  value).  Since we shouldn't ever call
12896                  decl_constant_value on a template type, there's no
12897                  reason to do that when processing_template_decl.
12898                  And, if the expression is something like a
12899                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12900                  wreak havoc on the intended type of the expression.
12901
12902                  Of course, there's also no point in trying to compute
12903                  minimum or maximum values if we're in a template.  */
12904               TREE_TYPE (value) = enumtype;
12905
12906               if (!minnode)
12907                 minnode = maxnode = value;
12908               else if (tree_int_cst_lt (maxnode, value))
12909                 maxnode = value;
12910               else if (tree_int_cst_lt (value, minnode))
12911                 minnode = value;
12912             }
12913
12914           if (processing_template_decl)
12915             /* If this is just a template, leave the CONST_DECL
12916                alone.  That way tsubst_copy will find CONST_DECLs for
12917                CONST_DECLs, and not INTEGER_CSTs.  */
12918             ;
12919           else
12920             /* In the list we're building up, we want the enumeration
12921                values, not the CONST_DECLs.  */
12922             TREE_VALUE (pair) = value;
12923         }
12924     }
12925   else
12926     maxnode = minnode = integer_zero_node;
12927
12928   TYPE_VALUES (enumtype) = nreverse (values);
12929
12930   if (processing_template_decl)
12931     {
12932       tree scope = current_scope ();
12933       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12934         add_tree (build_min (TAG_DEFN, enumtype));
12935     }
12936   else
12937     {
12938       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12939       int lowprec = min_precision (minnode, unsignedp);
12940       int highprec = min_precision (maxnode, unsignedp);
12941       int precision = MAX (lowprec, highprec);
12942       tree tem;
12943
12944       TYPE_SIZE (enumtype) = NULL_TREE;
12945
12946       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12947
12948       TYPE_PRECISION (enumtype) = precision;
12949       if (unsignedp)
12950         fixup_unsigned_type (enumtype);
12951       else
12952         fixup_signed_type (enumtype);
12953
12954       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12955         /* Use the width of the narrowest normal C type which is wide
12956            enough.  */
12957         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12958                                                     (precision, 1));
12959       else
12960         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12961
12962       TYPE_SIZE (enumtype) = 0;
12963       layout_type (enumtype);
12964
12965       /* Fix up all variant types of this enum type.  */
12966       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12967            tem = TYPE_NEXT_VARIANT (tem))
12968         {
12969           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12970           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12971           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12972           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12973           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12974           TYPE_MODE (tem) = TYPE_MODE (enumtype);
12975           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12976           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12977           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12978         }
12979
12980       /* Finish debugging output for this type.  */
12981       rest_of_type_compilation (enumtype, namespace_bindings_p ());
12982     }
12983
12984   return enumtype;
12985 }
12986
12987 /* Build and install a CONST_DECL for an enumeration constant of the
12988    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12989    Assignment of sequential values by default is handled here.  */
12990
12991 void
12992 build_enumerator (name, value, enumtype)
12993      tree name;
12994      tree value;
12995      tree enumtype;
12996 {
12997   tree decl;
12998   tree context;
12999   tree type;
13000   tree values;
13001
13002   /* Remove no-op casts from the value.  */
13003   if (value)
13004     STRIP_TYPE_NOPS (value);
13005
13006   if (! processing_template_decl)
13007     {
13008       /* Validate and default VALUE.  */
13009       if (value != NULL_TREE)
13010         {
13011           if (TREE_READONLY_DECL_P (value))
13012             value = decl_constant_value (value);
13013
13014           if (TREE_CODE (value) == INTEGER_CST)
13015             {
13016               value = default_conversion (value);
13017               constant_expression_warning (value);
13018             }
13019           else
13020             {
13021               cp_error ("enumerator value for `%D' not integer constant", name);
13022               value = NULL_TREE;
13023             }
13024         }
13025
13026       /* Default based on previous value.  */
13027       if (value == NULL_TREE && ! processing_template_decl)
13028         {
13029           tree prev_value;
13030
13031           if (TYPE_VALUES (enumtype))
13032             {
13033               /* The next value is the previous value ... */
13034               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13035               /* ... plus one.  */
13036               value = build_binary_op (PLUS_EXPR,
13037                                        prev_value,
13038                                        integer_one_node);
13039
13040               if (tree_int_cst_lt (value, prev_value))
13041                 cp_error ("overflow in enumeration values at `%D'", name);
13042             }
13043           else
13044             value = integer_zero_node;
13045         }
13046
13047       /* Remove no-op casts from the value.  */
13048       if (value)
13049         STRIP_TYPE_NOPS (value);
13050 #if 0
13051       /* To fix MAX_VAL enum consts. (bkoz)  */
13052       TREE_TYPE (value) = integer_type_node;
13053 #endif
13054     }
13055
13056   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13057      Even in other cases, we will later (in finish_enum) be setting
13058      the type of VALUE.  But, we don't need to make a copy if this
13059      VALUE is one of the enumeration constants for this same
13060      enumeration type.  */
13061   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13062     if (TREE_VALUE (values) == value)
13063       break;
13064   /* If we didn't break out of the loop, then we do need a copy.  */
13065   if (!values && value)
13066     value = copy_node (value);
13067
13068   /* C++ associates enums with global, function, or class declarations.  */
13069   context = current_scope ();
13070
13071   /* Build the actual enumeration constant.  Note that the enumeration
13072     constants have the type of their initializers until the
13073     enumeration is complete:
13074
13075       [ dcl.enum ]
13076
13077       Following the closing brace of an enum-specifier, each enumer-
13078       ator has the type of its enumeration.  Prior to the closing
13079       brace, the type of each enumerator is the type of its
13080       initializing value.
13081
13082     In finish_enum we will reset the type.  Of course, if we're
13083     processing a template, there may be no value.   */
13084   type = value ? TREE_TYPE (value) : NULL_TREE;
13085
13086   if (context && context == current_class_type)
13087     /* This enum declaration is local to the class.  We need the full
13088       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13089     decl = build_lang_decl (CONST_DECL, name, type);
13090   else
13091     /* It's a global enum, or it's local to a function.  (Note local to
13092       a function could mean local to a class method.  */
13093     decl = build_decl (CONST_DECL, name, type);
13094
13095   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13096   DECL_INITIAL (decl) = value;
13097   TREE_READONLY (decl) = 1;
13098
13099   if (context && context == current_class_type)
13100     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13101       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13102       things like `S::i' later.)  */
13103     finish_member_declaration (decl);
13104   else
13105     {
13106       pushdecl (decl);
13107       GNU_xref_decl (current_function_decl, decl);
13108     }
13109
13110   /* Add this enumeration constant to the list for this type.  */
13111   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13112 }
13113
13114 \f
13115 static int function_depth;
13116
13117 /* We're defining DECL.  Make sure that it's type is OK.  */
13118
13119 static void
13120 check_function_type (decl)
13121      tree decl;
13122 {
13123   tree fntype = TREE_TYPE (decl);
13124   tree return_type = complete_type (TREE_TYPE (fntype));
13125
13126   /* In a function definition, arg types must be complete.  */
13127   require_complete_types_for_parms (current_function_parms);
13128
13129   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13130     {
13131       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13132
13133       /* Make it return void instead, but don't change the
13134          type of the DECL_RESULT, in case we have a named return value.  */
13135       if (TREE_CODE (fntype) == METHOD_TYPE)
13136         {
13137           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13138           TREE_TYPE (decl)
13139             = build_cplus_method_type (ctype,
13140                                        void_type_node,
13141                                        FUNCTION_ARG_CHAIN (decl));
13142         }
13143       else
13144         TREE_TYPE (decl)
13145           = build_function_type (void_type_node,
13146                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13147       TREE_TYPE (decl)
13148         = build_exception_variant (fntype,
13149                                    TYPE_RAISES_EXCEPTIONS (fntype));
13150     }
13151   else
13152     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13153 }
13154
13155 /* Create the FUNCTION_DECL for a function definition.
13156    DECLSPECS and DECLARATOR are the parts of the declaration;
13157    they describe the function's name and the type it returns,
13158    but twisted together in a fashion that parallels the syntax of C.
13159
13160    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13161    DECLARATOR is really the DECL for the function we are about to
13162    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13163    indicating that the function is an inline defined in-class, and
13164    SF_EXPAND indicating that we should generate RTL for this
13165    function.
13166
13167    This function creates a binding context for the function body
13168    as well as setting up the FUNCTION_DECL in current_function_decl.
13169
13170    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13171    (it defines a datum instead), we return 0, which tells
13172    yyparse to report a parse error.
13173
13174    For C++, we must first check whether that datum makes any sense.
13175    For example, "class A local_a(1,2);" means that variable local_a
13176    is an aggregate of type A, which should have a constructor
13177    applied to it with the argument list [1, 2].  */
13178
13179 int
13180 start_function (declspecs, declarator, attrs, flags)
13181      tree declspecs, declarator, attrs;
13182      int flags;
13183 {
13184   tree decl1;
13185   tree ctype = NULL_TREE;
13186   tree fntype;
13187   tree restype;
13188   extern int have_extern_spec;
13189   extern int used_extern_spec;
13190   int doing_friend = 0;
13191   struct binding_level *bl;
13192
13193   /* Sanity check.  */
13194   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13195   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13196
13197   /* This should only be done once on the top most decl.  */
13198   if (have_extern_spec && !used_extern_spec)
13199     {
13200       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13201       used_extern_spec = 1;
13202     }
13203
13204   if (flags & SF_PRE_PARSED)
13205     {
13206       decl1 = declarator;
13207
13208       fntype = TREE_TYPE (decl1);
13209       if (TREE_CODE (fntype) == METHOD_TYPE)
13210         ctype = TYPE_METHOD_BASETYPE (fntype);
13211
13212       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13213          the (lexical) scope of the class in which it is defined.  */
13214       if (!ctype && DECL_FRIEND_P (decl1))
13215         {
13216           ctype = DECL_FRIEND_CONTEXT (decl1);
13217
13218           /* CTYPE could be null here if we're dealing with a template;
13219              for example, `inline friend float foo()' inside a template
13220              will have no CTYPE set.  */
13221           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13222             ctype = NULL_TREE;
13223           else
13224             doing_friend = 1;
13225         }
13226
13227       last_function_parms = DECL_ARGUMENTS (decl1);
13228       last_function_parm_tags = NULL_TREE;
13229     }
13230   else
13231     {
13232       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13233       /* If the declarator is not suitable for a function definition,
13234          cause a syntax error.  */
13235       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13236
13237       fntype = TREE_TYPE (decl1);
13238
13239       restype = TREE_TYPE (fntype);
13240       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13241         {
13242           cp_error ("semicolon missing after declaration of `%#T'", restype);
13243           shadow_tag (build_tree_list (NULL_TREE, restype));
13244           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13245           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13246             fntype = build_function_type (integer_type_node,
13247                                           TYPE_ARG_TYPES (fntype));
13248           else
13249             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13250                                               integer_type_node,
13251                                               TYPE_ARG_TYPES (fntype));
13252           TREE_TYPE (decl1) = fntype;
13253         }
13254
13255       if (TREE_CODE (fntype) == METHOD_TYPE)
13256         ctype = TYPE_METHOD_BASETYPE (fntype);
13257       else if (DECL_MAIN_P (decl1))
13258         {
13259           /* If this doesn't return integer_type, complain.  */
13260           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13261             {
13262               if (pedantic || warn_return_type)
13263                 pedwarn ("return type for `main' changed to `int'");
13264               TREE_TYPE (decl1) = fntype = default_function_type;
13265             }
13266         }
13267     }
13268
13269   /* Sometimes we don't notice that a function is a static member, and
13270      build a METHOD_TYPE for it.  Fix that up now.  */
13271   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13272       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13273     {
13274       revert_static_member_fn (decl1);
13275       last_function_parms = TREE_CHAIN (last_function_parms);
13276       ctype = NULL_TREE;
13277     }
13278
13279   /* Warn if function was previously implicitly declared
13280      (but not if we warned then).  */
13281   if (! warn_implicit
13282       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13283     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13284
13285   /* Set up current_class_type, and enter the scope of the class, if
13286      appropriate.  */
13287   if (ctype)
13288     push_nested_class (ctype, 1);
13289   else if (DECL_STATIC_FUNCTION_P (decl1))
13290     push_nested_class (DECL_CONTEXT (decl1), 2);
13291
13292   /* Now that we have entered the scope of the class, we must restore
13293      the bindings for any template parameters surrounding DECL1, if it
13294      is an inline member template.  (Order is important; consider the
13295      case where a template parameter has the same name as a field of
13296      the class.)  It is not until after this point that
13297      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13298   if (flags & SF_INCLASS_INLINE)
13299     maybe_begin_member_template_processing (decl1);
13300
13301   /* Effective C++ rule 15.  See also c_expand_return.  */
13302   if (warn_ecpp
13303       && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
13304       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13305     cp_warning ("`operator=' should return a reference to `*this'");
13306
13307   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13308      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13309   if (!DECL_INITIAL (decl1))
13310     DECL_INITIAL (decl1) = error_mark_node;
13311
13312 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13313   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13314 #endif
13315
13316   /* This function exists in static storage.
13317      (This does not mean `static' in the C sense!)  */
13318   TREE_STATIC (decl1) = 1;
13319
13320   /* We must call push_template_decl after current_class_type is set
13321      up.  (If we are processing inline definitions after exiting a
13322      class scope, current_class_type will be NULL_TREE until set above
13323      by push_nested_class.)  */
13324   if (processing_template_decl)
13325     decl1 = push_template_decl (decl1);
13326
13327   /* We are now in the scope of the function being defined.  */
13328   current_function_decl = decl1;
13329
13330   /* Save the parm names or decls from this function's declarator
13331      where store_parm_decls will find them.  */
13332   current_function_parms = last_function_parms;
13333   current_function_parm_tags = last_function_parm_tags;
13334
13335   /* Make sure the parameter and return types are reasonable.  When
13336      you declare a function, these types can be incomplete, but they
13337      must be complete when you define the function.  */
13338   if (! processing_template_decl)
13339     check_function_type (decl1);
13340
13341   /* Build the return declaration for the function.  */
13342   restype = TREE_TYPE (fntype);
13343   if (!processing_template_decl)
13344     {
13345       if (!DECL_RESULT (decl1))
13346         {
13347           DECL_RESULT (decl1)
13348             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13349           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13350                                       DECL_RESULT (decl1));
13351         }
13352     }
13353   else
13354     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13355     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13356
13357   /* Initialize RTL machinery.  We cannot do this until
13358      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13359      even when processing a template; this is how we get
13360      CFUN set up, and our per-function variables initialized.  */
13361   bl = current_binding_level;
13362   init_function_start (decl1, input_filename, lineno);
13363   current_binding_level = bl;
13364   expanding_p = (flags & SF_EXPAND) != 0;
13365
13366   /* Even though we're inside a function body, we still don't want to
13367      call expand_expr to calculate the size of a variable-sized array.
13368      We haven't necessarily assigned RTL to all variables yet, so it's
13369      not safe to try to expand expressions involving them.  */
13370   immediate_size_expand = 0;
13371   cfun->x_dont_save_pending_sizes_p = 1;
13372
13373   /* If we're building a statement-tree, start the tree now.  */
13374   if (processing_template_decl || !expanding_p)
13375     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13376
13377   /* Let the user know we're compiling this function.  */
13378   if (processing_template_decl || !building_stmt_tree ())
13379     announce_function (decl1);
13380
13381   /* Record the decl so that the function name is defined.
13382      If we already have a decl for this name, and it is a FUNCTION_DECL,
13383      use the old decl.  */
13384   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13385     {
13386       /* A specialization is not used to guide overload resolution.  */
13387       if ((flag_guiding_decls
13388            || !DECL_TEMPLATE_SPECIALIZATION (decl1))
13389           && ! DECL_FUNCTION_MEMBER_P (decl1))
13390         decl1 = pushdecl (decl1);
13391       else
13392         {
13393           /* We need to set the DECL_CONTEXT. */
13394           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13395             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13396           /* And make sure we have enough default args.  */
13397           check_default_args (decl1);
13398         }
13399       fntype = TREE_TYPE (decl1);
13400     }
13401
13402   /* Reset these in case the call to pushdecl changed them.  */
13403   current_function_decl = decl1;
13404   cfun->decl = decl1;
13405
13406   /* Initialize the per-function data.  */
13407   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13408     {
13409       /* If we already parsed this function, and we're just expanding it
13410          now, restore saved state.  */
13411       struct binding_level *bl = current_binding_level;
13412       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13413       current_binding_level = bl;
13414
13415       /* This function is being processed in whole-function mode; we
13416          already did semantic analysis.  */
13417       cfun->x_whole_function_mode_p = 1;
13418
13419       /* If we decided that we didn't want to inline this function,
13420          make sure the back-end knows that.  */
13421       if (!current_function_cannot_inline)
13422         current_function_cannot_inline = cp_function_chain->cannot_inline;
13423
13424       /* We don't need the saved data anymore.  */
13425       free (DECL_SAVED_FUNCTION_DATA (decl1));
13426       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13427     }
13428   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13429     {
13430       /* We know that this was set up by `grokclassfn'.  We do not
13431          wait until `store_parm_decls', since evil parse errors may
13432          never get us to that point.  Here we keep the consistency
13433          between `current_class_type' and `current_class_ptr'.  */
13434       tree t = DECL_ARGUMENTS (decl1);
13435
13436       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13437                           162);
13438       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13439                           19990811);
13440
13441       cp_function_chain->x_current_class_ref
13442         = build_indirect_ref (t, NULL_PTR);
13443       cp_function_chain->x_current_class_ptr = t;
13444
13445       /* Constructors and destructors need to know whether they're "in
13446          charge" of initializing virtual base classes.  */
13447       if (DECL_CONSTRUCTOR_FOR_VBASE_P (decl1)
13448           || DECL_DESTRUCTOR_P (decl1))
13449         current_in_charge_parm = TREE_CHAIN (t);
13450     }
13451
13452   if (DECL_INTERFACE_KNOWN (decl1))
13453     {
13454       tree ctx = decl_function_context (decl1);
13455
13456       if (DECL_NOT_REALLY_EXTERN (decl1))
13457         DECL_EXTERNAL (decl1) = 0;
13458
13459       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13460           && TREE_PUBLIC (ctx))
13461         /* This is a function in a local class in an extern inline
13462            function.  */
13463         comdat_linkage (decl1);
13464     }
13465   /* If this function belongs to an interface, it is public.
13466      If it belongs to someone else's interface, it is also external.
13467      This only affects inlines and template instantiations.  */
13468   else if (interface_unknown == 0
13469            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13470                || flag_alt_external_templates))
13471     {
13472       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13473           || processing_template_decl)
13474         {
13475           DECL_EXTERNAL (decl1)
13476             = (interface_only
13477                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13478                    && !DECL_VINDEX (decl1)));
13479
13480           /* For WIN32 we also want to put these in linkonce sections.  */
13481           maybe_make_one_only (decl1);
13482         }
13483       else
13484         DECL_EXTERNAL (decl1) = 0;
13485       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13486       DECL_INTERFACE_KNOWN (decl1) = 1;
13487     }
13488   else if (interface_unknown && interface_only
13489            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13490                || flag_alt_external_templates))
13491     {
13492       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13493          interface, we will have interface_only set but not
13494          interface_known.  In that case, we don't want to use the normal
13495          heuristics because someone will supply a #pragma implementation
13496          elsewhere, and deducing it here would produce a conflict.  */
13497       comdat_linkage (decl1);
13498       DECL_EXTERNAL (decl1) = 0;
13499       DECL_INTERFACE_KNOWN (decl1) = 1;
13500       DECL_DEFER_OUTPUT (decl1) = 1;
13501     }
13502   else
13503     {
13504       /* This is a definition, not a reference.
13505          So clear DECL_EXTERNAL.  */
13506       DECL_EXTERNAL (decl1) = 0;
13507
13508       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13509           && ! DECL_INTERFACE_KNOWN (decl1)
13510           /* Don't try to defer nested functions for now.  */
13511           && ! decl_function_context (decl1))
13512         DECL_DEFER_OUTPUT (decl1) = 1;
13513       else
13514         DECL_INTERFACE_KNOWN (decl1) = 1;
13515     }
13516
13517   if (doing_semantic_analysis_p ())
13518     {
13519       pushlevel (0);
13520       current_binding_level->parm_flag = 1;
13521     }
13522
13523   if (attrs)
13524     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13525
13526   if (!building_stmt_tree ())
13527     {
13528       GNU_xref_function (decl1, current_function_parms);
13529       make_function_rtl (decl1);
13530     }
13531
13532   /* Promote the value to int before returning it.  */
13533   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13534     restype = type_promotes_to (restype);
13535
13536   /* If this fcn was already referenced via a block-scope `extern' decl
13537      (or an implicit decl), propagate certain information about the usage.  */
13538   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13539     TREE_ADDRESSABLE (decl1) = 1;
13540
13541   if (DECL_RESULT (decl1) == NULL_TREE)
13542     {
13543       DECL_RESULT (decl1)
13544         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13545       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13546       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13547     }
13548
13549   ++function_depth;
13550
13551   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
13552       && DECL_LANGUAGE (decl1) == lang_cplusplus)
13553     {
13554       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13555       DECL_CONTEXT (dtor_label) = current_function_decl;
13556     }
13557   /* Under the old ABI we return `this' from constructors, so we make
13558      ordinary `return' statements in constructors jump to CTOR_LABEL;
13559      from there we return `this'.  Under the new ABI, we don't bother
13560      with any of this.  By not setting CTOR_LABEL the remainder of the
13561      machinery is automatically disabled.  */
13562   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13563     {
13564       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13565       DECL_CONTEXT (ctor_label) = current_function_decl;
13566     }
13567
13568   return 1;
13569 }
13570 \f
13571 /* Called after store_parm_decls for a function-try-block.  */
13572
13573 void
13574 expand_start_early_try_stmts ()
13575 {
13576   expand_start_try_stmts ();
13577 }
13578
13579 /* Store the parameter declarations into the current function declaration.
13580    This is called after parsing the parameter declarations, before
13581    digesting the body of the function.
13582
13583    Also install to binding contour return value identifier, if any.  */
13584
13585 void
13586 store_parm_decls ()
13587 {
13588   register tree fndecl = current_function_decl;
13589   register tree parm;
13590   int parms_have_cleanups = 0;
13591   tree cleanups = NULL_TREE;
13592
13593   /* This is a list of types declared among parms in a prototype.  */
13594   tree parmtags = current_function_parm_tags;
13595
13596   /* This is a chain of any other decls that came in among the parm
13597      declarations.  If a parm is declared with  enum {foo, bar} x;
13598      then CONST_DECLs for foo and bar are put here.  */
13599   tree nonparms = NULL_TREE;
13600
13601   /* Create a binding level for the parms.  */
13602   if (!building_stmt_tree ())
13603     expand_start_bindings (2);
13604
13605   if (current_function_parms)
13606     {
13607       /* This case is when the function was defined with an ANSI prototype.
13608          The parms already have decls, so we need not do anything here
13609          except record them as in effect
13610          and complain if any redundant old-style parm decls were written.  */
13611
13612       tree specparms = current_function_parms;
13613       tree next;
13614
13615       if (doing_semantic_analysis_p ())
13616         {
13617           /* Must clear this because it might contain TYPE_DECLs declared
13618              at class level.  */
13619           storedecls (NULL_TREE);
13620
13621           /* If we're doing semantic analysis, then we'll call pushdecl
13622              for each of these.  We must do them in reverse order so that
13623              they end in the correct forward order.  */
13624           specparms = nreverse (specparms);
13625         }
13626
13627       for (parm = specparms; parm; parm = next)
13628         {
13629           next = TREE_CHAIN (parm);
13630           if (TREE_CODE (parm) == PARM_DECL)
13631             {
13632               tree type = TREE_TYPE (parm);
13633
13634               if (doing_semantic_analysis_p ())
13635                 {
13636                   tree cleanup;
13637
13638                   if (DECL_NAME (parm) == NULL_TREE
13639                       || TREE_CODE (parm) != VOID_TYPE)
13640                     pushdecl (parm);
13641                   else
13642                     cp_error ("parameter `%D' declared void", parm);
13643
13644                   cleanup = (processing_template_decl
13645                              ? NULL_TREE
13646                              : maybe_build_cleanup (parm));
13647
13648                   if (cleanup)
13649                     cleanups = tree_cons (parm, cleanup, cleanups);
13650                 }
13651               else if (type != error_mark_node
13652                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13653                 parms_have_cleanups = 1;
13654             }
13655           else
13656             {
13657               /* If we find an enum constant or a type tag,
13658                  put it aside for the moment.  */
13659               TREE_CHAIN (parm) = NULL_TREE;
13660               nonparms = chainon (nonparms, parm);
13661             }
13662         }
13663
13664       if (doing_semantic_analysis_p ())
13665         {
13666           /* Get the decls in their original chain order
13667              and record in the function.  This is all and only the
13668              PARM_DECLs that were pushed into scope by the loop above.  */
13669           DECL_ARGUMENTS (fndecl) = getdecls ();
13670           storetags (chainon (parmtags, gettags ()));
13671         }
13672     }
13673   else
13674     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13675
13676   /* Now store the final chain of decls for the arguments
13677      as the decl-chain of the current lexical scope.
13678      Put the enumerators in as well, at the front so that
13679      DECL_ARGUMENTS is not modified.  */
13680   if (doing_semantic_analysis_p ())
13681     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13682
13683   /* Initialize the RTL code for the function.  */
13684   DECL_SAVED_INSNS (fndecl) = 0;
13685   if (! building_stmt_tree ())
13686     expand_function_start (fndecl, parms_have_cleanups);
13687
13688   current_function_parms_stored = 1;
13689
13690   /* If this function is `main', emit a call to `__main'
13691      to run global initializers, etc.  */
13692   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13693     expand_main_function ();
13694
13695   /* Now that we have initialized the parms, we can start their
13696      cleanups.  We cannot do this before, since expand_decl_cleanup
13697      should not be called before the parm can be used.  */
13698   while (cleanups)
13699     {
13700       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13701                            TREE_VALUE (cleanups));
13702       cleanups = TREE_CHAIN (cleanups);
13703     }
13704
13705   /* Create a binding contour which can be used to catch
13706      cleanup-generated temporaries.  Also, if the return value needs or
13707      has initialization, deal with that now.  */
13708   if (parms_have_cleanups)
13709     {
13710       pushlevel (0);
13711       if (!building_stmt_tree ())
13712         expand_start_bindings (2);
13713     }
13714
13715   /* Do the starting of the exception specifications, if we have any.  */
13716   if (flag_exceptions && !processing_template_decl
13717       && flag_enforce_eh_specs
13718       && building_stmt_tree ()
13719       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13720     current_eh_spec_try_block = expand_start_eh_spec ();
13721 }
13722
13723 /* Bind a name and initialization to the return value of
13724    the current function.  */
13725
13726 void
13727 store_return_init (decl)
13728      tree decl;
13729 {
13730   /* If this named return value comes in a register, put it in a
13731      pseudo-register.  */
13732   if (DECL_REGISTER (decl))
13733     {
13734       original_result_rtx = DECL_RTL (decl);
13735       /* Note that the mode of the old DECL_RTL may be wider than the
13736          mode of DECL_RESULT, depending on the calling conventions for
13737          the processor.  For example, on the Alpha, a 32-bit integer
13738          is returned in a DImode register -- the DECL_RESULT has
13739          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
13740          here, we use the mode the back-end has already assigned for
13741          the return value.  */
13742       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13743     }
13744 }
13745
13746 \f
13747 /* We have finished doing semantic analysis on DECL, but have not yet
13748    generated RTL for its body.  Save away our current state, so that
13749    when we want to generate RTL later we know what to do.  */
13750
13751 static void
13752 save_function_data (decl)
13753      tree decl;
13754 {
13755   struct language_function *f;
13756
13757   /* Save the language-specific per-function data so that we can
13758      get it back when we really expand this function.  */
13759   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13760                       19990908);
13761
13762   /* Make a copy.  */
13763   f = ((struct language_function *)
13764        xmalloc (sizeof (struct language_function)));
13765   bcopy ((char *) cp_function_chain, (char *) f,
13766          sizeof (struct language_function));
13767   DECL_SAVED_FUNCTION_DATA (decl) = f;
13768
13769   /* Clear out the bits we don't need.  */
13770   f->x_base_init_list = NULL_TREE;
13771   f->x_member_init_list = NULL_TREE;
13772   f->x_stmt_tree.x_last_stmt = NULL_TREE;
13773   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
13774   f->x_result_rtx = NULL_RTX;
13775   f->x_named_label_uses = NULL;
13776   f->bindings = NULL;
13777
13778   /* When we get back here again, we will be expanding.  */
13779   f->x_expanding_p = 1;
13780
13781   /* If we've already decided that we cannot inline this function, we
13782      must remember that fact when we actually go to expand the
13783      function.  */
13784   f->cannot_inline = current_function_cannot_inline;
13785 }
13786
13787 /* At the end of every constructor we generate to code to return
13788    `this'.  Do that now.  */
13789
13790 static void
13791 finish_constructor_body ()
13792 {
13793   /* Any return from a constructor will end up here.  */
13794   if (ctor_label)
13795     add_tree (build_min_nt (LABEL_STMT, ctor_label));
13796
13797   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13798      generate the return, rather than a goto to CTOR_LABEL.  */
13799   ctor_label = NULL_TREE;
13800   /* In check_return_expr we translate an empty return from a
13801      constructor to a return of `this'.  */
13802   finish_return_stmt (NULL_TREE);
13803   /* Mark the end of the constructor.  */
13804   add_tree (build_min_nt (CTOR_STMT));
13805 }
13806
13807 /* At the end of every destructor we generate code to restore virtual
13808    function tables to the values desired by base classes and to call
13809    to base class destructors.  Do that now.  */
13810
13811 static void
13812 finish_destructor_body ()
13813 {
13814   tree compound_stmt;
13815   tree in_charge;
13816   tree virtual_size;
13817   tree exprstmt;
13818
13819   /* Create a block to contain all the extra code.  */
13820   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13821
13822   /* Any return from a destructor will end up here.  */
13823   add_tree (build_min_nt (LABEL_STMT, dtor_label));
13824
13825   /* Generate the code to call destructor on base class.  If this
13826      destructor belongs to a class with virtual functions, then set
13827      the virtual function table pointer to represent the type of our
13828      base class.  */
13829
13830   /* This side-effect makes call to `build_delete' generate the code
13831      we have to have at the end of this destructor.  `build_delete'
13832      will set the flag again.  */
13833   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13834
13835   /* These are two cases where we cannot delegate deletion.  */
13836   if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
13837       || TYPE_GETS_REG_DELETE (current_class_type))
13838     in_charge = integer_zero_node;
13839   else
13840     in_charge = current_in_charge_parm;
13841
13842   exprstmt = build_delete (current_class_type,
13843                            current_class_ref,
13844                            in_charge,
13845                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13846                            0);
13847
13848   if (exprstmt != error_mark_node
13849       && (TREE_CODE (exprstmt) != NOP_EXPR
13850           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13851           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13852     {
13853       if (exprstmt != void_zero_node)
13854         /* Don't call `expand_expr_stmt' if we're not going to do
13855            anything, since -Wall will give a diagnostic.  */
13856         finish_expr_stmt (exprstmt);
13857
13858       /* Run destructors for all virtual baseclasses.  */
13859       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13860         {
13861           tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
13862           tree if_stmt = begin_if_stmt ();
13863           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13864                                       current_in_charge_parm,
13865                                       integer_two_node),
13866                                if_stmt);
13867
13868           while (vbases)
13869             {
13870               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbases)))
13871                 {
13872                   tree vb = get_vbase
13873                     (BINFO_TYPE (vbases),
13874                      TYPE_BINFO (current_class_type));
13875                   finish_expr_stmt
13876                     (build_scoped_method_call
13877                      (current_class_ref, vb, dtor_identifier,
13878                       build_tree_list (NULL_TREE, integer_zero_node)));
13879                 }
13880               vbases = TREE_CHAIN (vbases);
13881             }
13882
13883           finish_then_clause (if_stmt);
13884           finish_if_stmt ();
13885         }
13886     }
13887
13888   virtual_size = c_sizeof (current_class_type);
13889
13890   /* At the end, call delete if that's what's requested.  */
13891
13892   /* FDIS sez: At the point of definition of a virtual destructor
13893      (including an implicit definition), non-placement operator delete
13894      shall be looked up in the scope of the destructor's class and if
13895      found shall be accessible and unambiguous.
13896
13897      This is somewhat unclear, but I take it to mean that if the class
13898      only defines placement deletes we don't do anything here.  So we
13899      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13900      they ever try to delete one of these.  */
13901   if (TYPE_GETS_REG_DELETE (current_class_type)
13902       || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13903     {
13904       tree if_stmt;
13905
13906       exprstmt = build_op_delete_call
13907         (DELETE_EXPR, current_class_ptr, virtual_size,
13908          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13909
13910       if_stmt = begin_if_stmt ();
13911       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13912                                   current_in_charge_parm,
13913                                   integer_one_node),
13914                            if_stmt);
13915       finish_expr_stmt (exprstmt);
13916       finish_then_clause (if_stmt);
13917       finish_if_stmt ();
13918     }
13919
13920   /* Close the block we started above.  */
13921   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13922 }
13923
13924 /* Finish up a function declaration and compile that function
13925    all the way to assembler language output.  The free the storage
13926    for the function definition.
13927
13928    This is called after parsing the body of the function definition.
13929    LINENO is the current line number.
13930
13931    FLAGS is a bitwise or of the following values:
13932      1 - CALL_POPLEVEL
13933        An extra call to poplevel (and expand_end_bindings) must be
13934        made to take care of the binding contour for the base
13935        initializers.  This is only relevant for constructors.
13936      2 - INCLASS_INLINE
13937        We just finished processing the body of an in-class inline
13938        function definition.  (This processing will have taken place
13939        after the class definition is complete.)  */
13940
13941 tree
13942 finish_function (flags)
13943      int flags;
13944 {
13945   register tree fndecl = current_function_decl;
13946   tree fntype, ctype = NULL_TREE;
13947   /* Label to use if this function is supposed to return a value.  */
13948   tree no_return_label = NULL_TREE;
13949   int call_poplevel = (flags & 1) != 0;
13950   int inclass_inline = (flags & 2) != 0;
13951   int expand_p;
13952   int nested;
13953   int current_line = lineno;
13954
13955   /* When we get some parse errors, we can end up without a
13956      current_function_decl, so cope.  */
13957   if (fndecl == NULL_TREE)
13958     return error_mark_node;
13959
13960   nested = function_depth > 1;
13961   fntype = TREE_TYPE (fndecl);
13962
13963   /*  TREE_READONLY (fndecl) = 1;
13964       This caused &foo to be of type ptr-to-const-function
13965       which then got a warning when stored in a ptr-to-function variable.  */
13966
13967   /* This happens on strange parse errors.  */
13968   if (! current_function_parms_stored)
13969     {
13970       call_poplevel = 0;
13971       store_parm_decls ();
13972     }
13973
13974   if (building_stmt_tree ())
13975     {
13976       if (DECL_CONSTRUCTOR_P (fndecl))
13977         {
13978           finish_constructor_body ();
13979           if (call_poplevel)
13980             do_poplevel ();
13981         }
13982       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13983         finish_destructor_body ();
13984       else if (DECL_MAIN_P (fndecl))
13985         {
13986           /* Make it so that `main' always returns 0 by default.  */
13987 #ifdef VMS
13988           finish_return_stmt (integer_one_node);
13989 #else
13990           finish_return_stmt (integer_zero_node);
13991 #endif
13992         }
13993
13994       /* Finish dealing with exception specifiers.  */
13995       if (flag_exceptions && !processing_template_decl
13996           && flag_enforce_eh_specs
13997           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13998         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13999                             (TREE_TYPE (current_function_decl)),
14000                             current_eh_spec_try_block);
14001     }
14002   else
14003     {
14004 #if 0
14005       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14006         {
14007           /* Keep this code around in case we later want to control debug info
14008              based on whether a type is "used".  (jason 1999-11-11) */
14009
14010           tree ttype = target_type (fntype);
14011           tree parmdecl;
14012
14013           if (IS_AGGR_TYPE (ttype))
14014             /* Let debugger know it should output info for this type.  */
14015             note_debug_info_needed (ttype);
14016
14017           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14018             {
14019               ttype = target_type (TREE_TYPE (parmdecl));
14020               if (IS_AGGR_TYPE (ttype))
14021                 /* Let debugger know it should output info for this type.  */
14022                 note_debug_info_needed (ttype);
14023             }
14024         }
14025 #endif
14026
14027       /* Clean house because we will need to reorder insns here.  */
14028       do_pending_stack_adjust ();
14029
14030       if (dtor_label)
14031         ;
14032       else if (DECL_CONSTRUCTOR_P (fndecl))
14033         {
14034           if (call_poplevel)
14035             do_poplevel ();
14036         }
14037       else if (return_label != NULL_RTX
14038                && flag_this_is_variable <= 0
14039                && current_function_return_value == NULL_TREE
14040                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14041         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14042
14043       if (flag_exceptions)
14044         expand_exception_blocks ();
14045
14046       /* If this function is supposed to return a value, ensure that
14047          we do not fall into the cleanups by mistake.  The end of our
14048          function will look like this:
14049
14050          user code (may have return stmt somewhere)
14051          goto no_return_label
14052          cleanup_label:
14053          cleanups
14054          goto return_label
14055          no_return_label:
14056          NOTE_INSN_FUNCTION_END
14057          return_label:
14058          things for return
14059
14060          If the user omits a return stmt in the USER CODE section, we
14061          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14062          Otherwise, we won't.  */
14063       if (no_return_label)
14064         {
14065           DECL_CONTEXT (no_return_label) = fndecl;
14066           DECL_INITIAL (no_return_label) = error_mark_node;
14067           DECL_SOURCE_FILE (no_return_label) = input_filename;
14068           DECL_SOURCE_LINE (no_return_label) = current_line;
14069           expand_goto (no_return_label);
14070         }
14071
14072       if (cleanup_label)
14073         {
14074           /* Remove the binding contour which is used
14075              to catch cleanup-generated temporaries.  */
14076           expand_end_bindings (0, 0, 0);
14077           poplevel (0, 0, 0);
14078
14079           /* Emit label at beginning of cleanup code for parameters.  */
14080           emit_label (cleanup_label);
14081         }
14082
14083       /* Get return value into register if that's where it's supposed
14084          to be.  */
14085       if (original_result_rtx)
14086         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14087
14088       /* Finish building code that will trigger warnings if users forget
14089          to make their functions return values.  */
14090       if (no_return_label || cleanup_label)
14091         emit_jump (return_label);
14092       if (no_return_label)
14093         {
14094           /* We don't need to call `expand_*_return' here because we
14095              don't need any cleanups here--this path of code is only
14096              for error checking purposes.  */
14097           expand_label (no_return_label);
14098         }
14099
14100       /* We hard-wired immediate_size_expand to zero in
14101          start_function.  Expand_function_end will decrement this
14102          variable.  So, we set the variable to one here, so that after
14103          the decrement it will remain zero.  */
14104       immediate_size_expand = 1;
14105
14106       /* Generate rtl for function exit.  */
14107       expand_function_end (input_filename, current_line, 1);
14108     }
14109
14110   /* We have to save this value here in case
14111      maybe_end_member_template_processing decides to pop all the
14112      template parameters.  */
14113   expand_p = !building_stmt_tree ();
14114
14115   /* If we're saving up tree structure, tie off the function now.  */
14116   if (!expand_p)
14117     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14118
14119   /* This must come after expand_function_end because cleanups might
14120      have declarations (from inline functions) that need to go into
14121      this function's blocks.  */
14122   if (doing_semantic_analysis_p ())
14123     {
14124       if (current_binding_level->parm_flag != 1)
14125         my_friendly_abort (122);
14126       poplevel (1, 0, 1);
14127     }
14128
14129   /* Remember that we were in class scope.  */
14130   if (current_class_name)
14131     ctype = current_class_type;
14132
14133   /* Must mark the RESULT_DECL as being in this function.  */
14134   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14135
14136   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14137      to the FUNCTION_DECL node itself.  */
14138   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14139
14140   /* Save away current state, if appropriate.  */
14141   if (!expanding_p && !processing_template_decl)
14142     save_function_data (fndecl);
14143
14144   /* If this function calls `setjmp' it cannot be inlined.  When
14145      `longjmp' is called it is not guaranteed to restore the value of
14146      local variables that have been modified since the call to
14147      `setjmp'.  So, if were to inline this function into some caller
14148      `c', then when we `longjmp', we might not restore all variables
14149      in `c'.  (It might seem, at first blush, that there's no way for
14150      this function to modify local variables in `c', but their
14151      addresses may have been stored somewhere accessible to this
14152      function.)  */
14153   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14154     DECL_UNINLINABLE (fndecl) = 1;
14155
14156   if (expand_p)
14157     {
14158       int returns_null;
14159       int returns_value;
14160
14161       /* So we can tell if jump_optimize sets it to 1.  */
14162       can_reach_end = 0;
14163
14164       /* Before we call rest_of_compilation (which will pop the
14165          CURRENT_FUNCTION), we must save these values.  */
14166       returns_null = current_function_returns_null;
14167       returns_value = current_function_returns_value;
14168
14169       /* If this is a nested function (like a template instantiation
14170          that we're compiling in the midst of compiling something
14171          else), push a new GC context.  That will keep local variables
14172          on the stack from being collected while we're doing the
14173          compilation of this function.  */
14174       if (function_depth > 1)
14175         ggc_push_context ();
14176
14177       /* Run the optimizers and output the assembler code for this
14178          function.  */
14179       if (DECL_ARTIFICIAL (fndecl))
14180         {
14181           /* Do we really *want* to inline this synthesized method?  */
14182
14183           int save_fif = flag_inline_functions;
14184           flag_inline_functions = 1;
14185
14186           /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
14187              will check our size.  */
14188           DECL_INLINE (fndecl) = 0;
14189
14190           rest_of_compilation (fndecl);
14191           flag_inline_functions = save_fif;
14192         }
14193       else
14194         rest_of_compilation (fndecl);
14195
14196       /* Undo the call to ggc_push_context above.  */
14197       if (function_depth > 1)
14198         ggc_pop_context ();
14199
14200       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14201         {
14202           /* Set DECL_EXTERNAL so that assemble_external will be called as
14203              necessary.  We'll clear it again in finish_file.  */
14204           if (! DECL_EXTERNAL (fndecl))
14205             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14206           DECL_EXTERNAL (fndecl) = 1;
14207           defer_fn (fndecl);
14208         }
14209
14210 #if 0
14211       /* Keep this code around in case we later want to control debug info
14212          based on whether a type is "used".  (jason 1999-11-11) */
14213
14214       if (ctype && TREE_ASM_WRITTEN (fndecl))
14215         note_debug_info_needed (ctype);
14216 #endif
14217
14218       returns_null |= can_reach_end;
14219
14220       /* Since we don't normally go through c_expand_return for constructors,
14221          this normally gets the wrong value.
14222          Also, named return values have their return codes emitted after
14223          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
14224       if (DECL_CONSTRUCTOR_P (fndecl)
14225           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
14226         returns_null = 0;
14227
14228       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14229         cp_warning ("`noreturn' function `%D' does return", fndecl);
14230       else if ((warn_return_type || pedantic)
14231                && returns_null
14232                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14233         {
14234           /* If this function returns non-void and control can drop through,
14235              complain.  */
14236           cp_warning ("control reaches end of non-void function `%D'", fndecl);
14237         }
14238       /* With just -W, complain only if function returns both with
14239          and without a value.  */
14240       else if (extra_warnings && returns_value && returns_null)
14241         warning ("this function may return with or without a value");
14242     }
14243   else
14244     {
14245       /* Clear out memory we no longer need.  */
14246       free_after_parsing (cfun);
14247       /* Since we never call rest_of_compilation, we never clear
14248          CFUN.  Do so explicitly.  */
14249       free_after_compilation (cfun);
14250       cfun = NULL;
14251     }
14252
14253   /* If this is a in-class inline definition, we may have to pop the
14254      bindings for the template parameters that we added in
14255      maybe_begin_member_template_processing when start_function was
14256      called.  */
14257   if (inclass_inline)
14258     maybe_end_member_template_processing ();
14259
14260   /* Leave the scope of the class.  */
14261   if (ctype)
14262     pop_nested_class ();
14263
14264   --function_depth;
14265
14266   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14267       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14268     {
14269       tree t;
14270
14271       /* Stop pointing to the local nodes about to be freed.  */
14272       /* But DECL_INITIAL must remain nonzero so we know this
14273          was an actual function definition.  */
14274       DECL_INITIAL (fndecl) = error_mark_node;
14275       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14276         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14277     }
14278
14279   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14280     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14281   if (DECL_STATIC_DESTRUCTOR (fndecl))
14282     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14283
14284   /* Clean up.  */
14285   if (! nested)
14286     {
14287       /* Let the error reporting routines know that we're outside a
14288          function.  For a nested function, this value is used in
14289          pop_cp_function_context and then reset via pop_function_context.  */
14290       current_function_decl = NULL_TREE;
14291       /* We don't really care about obstacks, but the middle-end
14292          sometimes cares on what obstck things are located.  */
14293       permanent_allocation (1);
14294     }
14295
14296   return fndecl;
14297 }
14298 \f
14299 /* Create the FUNCTION_DECL for a function definition.
14300    DECLSPECS and DECLARATOR are the parts of the declaration;
14301    they describe the return type and the name of the function,
14302    but twisted together in a fashion that parallels the syntax of C.
14303
14304    This function creates a binding context for the function body
14305    as well as setting up the FUNCTION_DECL in current_function_decl.
14306
14307    Returns a FUNCTION_DECL on success.
14308
14309    If the DECLARATOR is not suitable for a function (it defines a datum
14310    instead), we return 0, which tells yyparse to report a parse error.
14311
14312    May return void_type_node indicating that this method is actually
14313    a friend.  See grokfield for more details.
14314
14315    Came here with a `.pushlevel' .
14316
14317    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14318    CHANGES TO CODE IN `grokfield'.  */
14319
14320 tree
14321 start_method (declspecs, declarator, attrlist)
14322      tree declarator, declspecs, attrlist;
14323 {
14324   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14325                                 attrlist);
14326
14327   /* Something too ugly to handle.  */
14328   if (fndecl == NULL_TREE)
14329     return NULL_TREE;
14330
14331   /* Pass friends other than inline friend functions back.  */
14332   if (fndecl == void_type_node)
14333     return fndecl;
14334
14335   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14336     /* Not a function, tell parser to report parse error.  */
14337     return NULL_TREE;
14338
14339   if (DECL_IN_AGGR_P (fndecl))
14340     {
14341       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14342         {
14343           if (DECL_CONTEXT (fndecl)
14344               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14345             cp_error ("`%D' is already defined in class %s", fndecl,
14346                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14347         }
14348       return void_type_node;
14349     }
14350
14351   check_template_shadow (fndecl);
14352
14353   DECL_THIS_INLINE (fndecl) = 1;
14354
14355   if (flag_default_inline)
14356     DECL_INLINE (fndecl) = 1;
14357
14358   /* We process method specializations in finish_struct_1.  */
14359   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14360     fndecl = push_template_decl (fndecl);
14361
14362   if (! DECL_FRIEND_P (fndecl))
14363     {
14364       if (TREE_CHAIN (fndecl))
14365         {
14366           fndecl = copy_node (fndecl);
14367           TREE_CHAIN (fndecl) = NULL_TREE;
14368         }
14369
14370       if (DECL_CONSTRUCTOR_P (fndecl))
14371         {
14372           if (! grok_ctor_properties (current_class_type, fndecl))
14373             return void_type_node;
14374         }
14375       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14376         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14377     }
14378
14379   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14380
14381   /* Make a place for the parms */
14382   pushlevel (0);
14383   current_binding_level->parm_flag = 1;
14384
14385   DECL_IN_AGGR_P (fndecl) = 1;
14386   return fndecl;
14387 }
14388
14389 /* Go through the motions of finishing a function definition.
14390    We don't compile this method until after the whole class has
14391    been processed.
14392
14393    FINISH_METHOD must return something that looks as though it
14394    came from GROKFIELD (since we are defining a method, after all).
14395
14396    This is called after parsing the body of the function definition.
14397    STMTS is the chain of statements that makes up the function body.
14398
14399    DECL is the ..._DECL that `start_method' provided.  */
14400
14401 tree
14402 finish_method (decl)
14403      tree decl;
14404 {
14405   register tree fndecl = decl;
14406   tree old_initial;
14407
14408   register tree link;
14409
14410   if (decl == void_type_node)
14411     return decl;
14412
14413   old_initial = DECL_INITIAL (fndecl);
14414
14415   /* Undo the level for the parms (from start_method).
14416      This is like poplevel, but it causes nothing to be
14417      saved.  Saving information here confuses symbol-table
14418      output routines.  Besides, this information will
14419      be correctly output when this method is actually
14420      compiled.  */
14421
14422   /* Clear out the meanings of the local variables of this level;
14423      also record in each decl which block it belongs to.  */
14424
14425   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14426     {
14427       if (DECL_NAME (link) != NULL_TREE)
14428         pop_binding (DECL_NAME (link), link);
14429       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14430       DECL_CONTEXT (link) = NULL_TREE;
14431     }
14432
14433   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14434                       (HOST_WIDE_INT) current_binding_level->level_chain,
14435                       current_binding_level->parm_flag,
14436                       current_binding_level->keep);
14437
14438   poplevel (0, 0, 0);
14439
14440   DECL_INITIAL (fndecl) = old_initial;
14441
14442   /* We used to check if the context of FNDECL was different from
14443      current_class_type as another way to get inside here.  This didn't work
14444      for String.cc in libg++.  */
14445   if (DECL_FRIEND_P (fndecl))
14446     {
14447       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14448         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14449       decl = void_type_node;
14450     }
14451
14452   return decl;
14453 }
14454 \f
14455 /* Called when a new struct TYPE is defined.
14456    If this structure or union completes the type of any previous
14457    variable declaration, lay it out and output its rtl.  */
14458
14459 void
14460 hack_incomplete_structures (type)
14461      tree type;
14462 {
14463   tree *list;
14464   struct binding_level *level;
14465
14466   if (!type) /* Don't do this for class templates.  */
14467     return;
14468
14469   if (namespace_bindings_p ())
14470     {
14471       level = 0;
14472       list = &namespace_scope_incomplete;
14473     }
14474   else
14475     {
14476       level = innermost_nonclass_level ();
14477       list = &level->incomplete;
14478     }
14479
14480   while (1)
14481     {
14482       while (*list)
14483         {
14484           tree decl = TREE_VALUE (*list);
14485           if ((decl && TREE_TYPE (decl) == type)
14486               || (TREE_TYPE (decl)
14487                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14488                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14489             {
14490               int toplevel = toplevel_bindings_p ();
14491               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14492                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14493                 layout_type (TREE_TYPE (decl));
14494               layout_decl (decl, 0);
14495               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14496               if (! toplevel)
14497                 {
14498                   tree cleanup;
14499                   expand_decl (decl);
14500                   cleanup = maybe_build_cleanup (decl);
14501                   expand_decl_init (decl);
14502                   if (! expand_decl_cleanup (decl, cleanup))
14503                     cp_error ("parser lost in parsing declaration of `%D'",
14504                               decl);
14505                 }
14506               *list = TREE_CHAIN (*list);
14507             }
14508           else
14509             list = &TREE_CHAIN (*list);
14510         }
14511
14512       /* Keep looking through artificial binding levels generated
14513          for local variables.  */
14514       if (level && level->keep == 2)
14515         {
14516           level = level->level_chain;
14517           list = &level->incomplete;
14518         }
14519       else
14520         break;
14521     }
14522 }
14523
14524 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14525    See build_delete for information about AUTO_DELETE.  */
14526
14527 static tree
14528 maybe_build_cleanup_1 (decl, auto_delete)
14529      tree decl, auto_delete;
14530 {
14531   tree type = TREE_TYPE (decl);
14532   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14533     {
14534       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14535       tree rval;
14536
14537       if (TREE_CODE (type) == ARRAY_TYPE)
14538         rval = decl;
14539       else
14540         {
14541           mark_addressable (decl);
14542           rval = build_unary_op (ADDR_EXPR, decl, 0);
14543         }
14544
14545       /* Optimize for space over speed here.  */
14546       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14547           || flag_expensive_optimizations)
14548         flags |= LOOKUP_NONVIRTUAL;
14549
14550       rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
14551
14552       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14553           && ! TYPE_HAS_DESTRUCTOR (type))
14554         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14555                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14556
14557       return rval;
14558     }
14559   return 0;
14560 }
14561
14562 /* If DECL is of a type which needs a cleanup, build that cleanup
14563    here.  The cleanup does free the storage with a call to delete.  */
14564
14565 tree
14566 maybe_build_cleanup_and_delete (decl)
14567      tree decl;
14568 {
14569   return maybe_build_cleanup_1 (decl, integer_three_node);
14570 }
14571
14572 /* If DECL is of a type which needs a cleanup, build that cleanup
14573    here.  The cleanup does not free the storage with a call a delete.  */
14574
14575 tree
14576 maybe_build_cleanup (decl)
14577      tree decl;
14578 {
14579   return maybe_build_cleanup_1 (decl, integer_two_node);
14580 }
14581 \f
14582 /* Expand a C++ expression at the statement level.
14583    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14584    The C++ type checker should get all of these out when
14585    expressions are combined with other, type-providing, expressions,
14586    leaving only orphan expressions, such as:
14587
14588    &class::bar;         / / takes its address, but does nothing with it.  */
14589
14590 void
14591 cplus_expand_expr_stmt (exp)
14592      tree exp;
14593 {
14594 #if 0
14595   /* We should do this eventually, but right now this causes regex.o from
14596      libg++ to miscompile, and tString to core dump.  */
14597   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14598 #endif
14599
14600   /* If we don't do this, we end up down inside expand_expr
14601      trying to do TYPE_MODE on the ERROR_MARK, and really
14602      go outside the bounds of the type.  */
14603   if (exp != error_mark_node)
14604     expand_expr_stmt (exp);
14605 }
14606
14607 /* When a stmt has been parsed, this function is called.  */
14608
14609 void
14610 finish_stmt ()
14611 {
14612   /* Always assume this statement was not an expression statement.  If
14613      it actually was an expression statement, its our callers
14614      responsibility to fix this up.  */
14615   last_expr_type = NULL_TREE;
14616 }
14617
14618 /* DECL was originally constructed as a non-static member function,
14619    but turned out to be static.  Update it accordingly.  */
14620
14621 void
14622 revert_static_member_fn (decl)
14623      tree decl;
14624 {
14625   tree tmp;
14626   tree function = TREE_TYPE (decl);
14627   tree args = TYPE_ARG_TYPES (function);
14628
14629   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14630       != TYPE_UNQUALIFIED)
14631     cp_error ("static member function `%#D' declared with type qualifiers",
14632               *decl);
14633
14634   args = TREE_CHAIN (args);
14635   tmp = build_function_type (TREE_TYPE (function), args);
14636   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14637   tmp = build_exception_variant (tmp,
14638                                  TYPE_RAISES_EXCEPTIONS (function));
14639   TREE_TYPE (decl) = tmp;
14640   if (DECL_ARGUMENTS (decl))
14641     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14642   DECL_STATIC_FUNCTION_P (decl) = 1;
14643 }
14644
14645 /* Initialize the variables used during compilation of a C++
14646    function.  */
14647
14648 static void
14649 push_cp_function_context (f)
14650      struct function *f;
14651 {
14652   struct language_function *p
14653     = ((struct language_function *)
14654        xcalloc (1, sizeof (struct language_function)));
14655   f->language = p;
14656
14657   /* It takes an explicit call to expand_body to generate RTL for a
14658      function.  */
14659   expanding_p = 0;
14660
14661   /* Whenever we start a new function, we destroy temporaries in the
14662      usual way.  */
14663   stmts_are_full_exprs_p = 1;
14664 }
14665
14666 /* Free the language-specific parts of F, now that we've finished
14667    compiling the function.  */
14668
14669 static void
14670 pop_cp_function_context (f)
14671      struct function *f;
14672 {
14673   if (f->language)
14674     free (f->language);
14675   f->language = 0;
14676 }
14677
14678 /* Mark P for GC.  */
14679
14680 static void
14681 mark_lang_function (p)
14682      struct language_function *p;
14683 {
14684   if (!p)
14685     return;
14686
14687   ggc_mark_tree (p->x_named_labels);
14688   ggc_mark_tree (p->x_ctor_label);
14689   ggc_mark_tree (p->x_dtor_label);
14690   ggc_mark_tree (p->x_base_init_list);
14691   ggc_mark_tree (p->x_member_init_list);
14692   ggc_mark_tree (p->x_current_class_ptr);
14693   ggc_mark_tree (p->x_current_class_ref);
14694   ggc_mark_tree (p->x_eh_spec_try_block);
14695   ggc_mark_tree (p->x_scope_stmt_stack);
14696
14697   ggc_mark_rtx (p->x_result_rtx);
14698
14699   mark_stmt_tree (&p->x_stmt_tree);
14700   mark_binding_level (&p->bindings);
14701 }
14702
14703 /* Mark the language-specific data in F for GC.  */
14704
14705 static void
14706 mark_cp_function_context (f)
14707      struct function *f;
14708 {
14709   mark_lang_function (f->language);
14710 }
14711
14712 void
14713 lang_mark_false_label_stack (l)
14714      struct label_node *l;
14715 {
14716   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14717   my_friendly_assert (l == NULL, 19990904);
14718 }
14719
14720 void
14721 lang_mark_tree (t)
14722      tree t;
14723 {
14724   enum tree_code code = TREE_CODE (t);
14725   if (code == IDENTIFIER_NODE)
14726     {
14727       struct lang_identifier *li = (struct lang_identifier *) t;
14728       struct lang_id2 *li2 = li->x;
14729       ggc_mark_tree (li->namespace_bindings);
14730       ggc_mark_tree (li->bindings);
14731       ggc_mark_tree (li->class_value);
14732       ggc_mark_tree (li->class_template_info);
14733
14734       if (li2)
14735         {
14736           ggc_mark_tree (li2->label_value);
14737           ggc_mark_tree (li2->implicit_decl);
14738           ggc_mark_tree (li2->error_locus);
14739         }
14740     }
14741   else if (code == CPLUS_BINDING)
14742     {
14743       if (BINDING_HAS_LEVEL_P (t))
14744         mark_binding_level (&BINDING_LEVEL (t));
14745       else
14746         ggc_mark_tree (BINDING_SCOPE (t));
14747       ggc_mark_tree (BINDING_VALUE (t));
14748     }
14749   else if (code == OVERLOAD)
14750     ggc_mark_tree (OVL_FUNCTION (t));
14751   else if (code == TEMPLATE_PARM_INDEX)
14752     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14753   else if (TREE_CODE_CLASS (code) == 'd')
14754     {
14755       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14756
14757       if (ld)
14758         {
14759           ggc_mark (ld);
14760           if (!DECL_GLOBAL_CTOR_P (t) && !DECL_GLOBAL_DTOR_P (t))
14761             ggc_mark_tree (ld->decl_flags.u2.access);
14762           ggc_mark_tree (ld->decl_flags.context);
14763           if (TREE_CODE (t) != NAMESPACE_DECL)
14764             ggc_mark_tree (ld->decl_flags.u.template_info);
14765           else
14766             mark_binding_level (&NAMESPACE_LEVEL (t));
14767           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14768             {
14769               ggc_mark_tree (ld->befriending_classes);
14770               ggc_mark_tree (ld->saved_tree);
14771               if (TREE_CODE (t) == TYPE_DECL)
14772                 ggc_mark_tree (ld->u.sorted_fields);
14773               else if (TREE_CODE (t) == FUNCTION_DECL
14774                        && !DECL_PENDING_INLINE_P (t))
14775                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14776             }
14777         }
14778     }
14779   else if (TREE_CODE_CLASS (code) == 't')
14780     {
14781       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14782
14783       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14784                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14785         {
14786           ggc_mark (lt);
14787           ggc_mark_tree (lt->vfields);
14788           ggc_mark_tree (lt->vbases);
14789           ggc_mark_tree (lt->tags);
14790           ggc_mark_tree (lt->search_slot);
14791           ggc_mark_tree (lt->size);
14792           ggc_mark_tree (lt->pure_virtuals);
14793           ggc_mark_tree (lt->friend_classes);
14794           ggc_mark_tree (lt->rtti);
14795           ggc_mark_tree (lt->methods);
14796           ggc_mark_tree (lt->template_info);
14797           ggc_mark_tree (lt->befriending_classes);
14798         }
14799       else if (lt)
14800         /* In the case of pointer-to-member function types, the
14801            TYPE_LANG_SPECIFIC is really just a tree.  */
14802         ggc_mark_tree ((tree) lt);
14803     }
14804 }